LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/CorpsK.c
// Function: MakeTableMul2_8
unsigned char ** MakeTableMul2_8() 
{
	int a,b,i;
	unsigned char aa,bb,r,t,**TableMul2_8;
	
	TableMul2_8=malloc(256*sizeof(unsigned char *));
	for (i = 0; i < 256; i++)
	{
		TableMul2_8[i]=malloc(256*sizeof(unsigned char));
	}
	for (a = 0; a <256 ; a++)
	{
		for (b = a; b < 256 ; b++)
		{
			aa=a;
			bb=b;
			r=0;
			while (aa != 0)
			{
				if ((aa & 1) != 0)
				{
					r=r^bb;
				}
				t=bb & 0x80;
				bb=bb<<1;
				if (t != 0)
				{
					bb=bb^0x1b;
				}
				aa=aa>>1;
			}
			TableMul2_8[a][b]=TableMul2_8[b][a]=r;	
		}
	}
	return TableMul2_8;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x800, %edi            # imm = 0x800
callq 0x21d0
movq %rax, %rbx
xorl %r14d, %r14d
movl $0x100, %edi            # imm = 0x100
callq 0x21d0
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x24a0
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
movq %rax, %rdx
xorl %esi, %esi
testq %rax, %rax
je 0x2509
movl %eax, %edi
movl %edx, %r9d
movl %eax, %r10d
movl %eax, %r8d
andl $0x1, %r10d
movzbl %r9b, %r9d
cmovnel %r9d, %r10d
xorb %r10b, %sil
leal (%r9,%r9), %r10d
movzbl %r10b, %r11d
xorb $0x1b, %r10b
testb %r9b, %r9b
movzbl %r10b, %r9d
cmovnsl %r11d, %r9d
shrl %r8d
movl %r8d, %r10d
cmpl $0x1, %edi
movl %r8d, %edi
ja 0x24d5
movq (%rbx,%rdx,8), %rdi
movb %sil, (%rdi,%rax)
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0x24c3
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x24bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: UnionListesTriees
int * UnionListesTriees(int * const L1, const int t1, int * const L2, const int t2, int *taille)
{
	int * __restrict Final=malloc((max(0,t1)+max(0,t2))*sizeof(int));
	int i=0, j=0, cpt=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]<=L2[j])
		{
			if (L1[i]==L2[j]) j++;
			Final[cpt++]=L1[i++];
		}
		else Final[cpt++]=L2[j++];
	}
	for (i = i; i < t1; i++) Final[cpt++]=L1[i];
	for (j = j; j < t2; j++) Final[cpt++]=L2[j];
	*taille=cpt;
	return Final;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movl %ecx, %r14d
movq %rdx, 0x10(%rsp)
movl %esi, %r12d
xorl %r15d, %r15d
testl %ecx, %ecx
movl $0x0, %ecx
cmovgl %r14d, %ecx
setle %bl
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movq %rdi, %r13
setle %bpl
addl %ecx, %eax
shlq $0x2, %rax
movq %rax, %rdi
callq 0x21d0
movq 0x10(%rsp), %r8
movq %rax, %rdi
orb %bl, %bpl
movl %r14d, %ebp
movl $0x0, %r14d
movl $0x0, %ebx
jne 0x25f3
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %r15d, %eax
movl %r14d, %ecx
movl %r15d, %edx
movl (%r13,%rdx,4), %edx
movl %r14d, %esi
movl (%r8,%rsi,4), %esi
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpl %esi, %edx
setle %r15b
cmovll %edx, %esi
setge %r14b
addl %eax, %r15d
movl %esi, (%rdi,%rbx,4)
addl %ecx, %r14d
incq %rbx
cmpl %r12d, %r15d
jge 0x25f3
cmpl %ebp, %r14d
jl 0x25b5
cmpl %r12d, %r15d
jge 0x2648
movl %ebp, 0xc(%rsp)
movl %ebx, %ebx
movq %rdi, 0x18(%rsp)
leaq (%rdi,%rbx,4), %rdi
movslq %r15d, %rbp
leaq (,%rbp,4), %rsi
addq %r13, %rsi
notl %r15d
addl %r12d, %r15d
leaq 0x4(,%r15,4), %rdx
callq 0x21b0
movslq %r12d, %rax
subq %rax, %rbp
xorl %eax, %eax
decq %rax
cmpq %rax, %rbp
jne 0x2630
subl %eax, %ebx
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %ebp
movq 0x10(%rsp), %r8
cmpl %ebp, %r14d
jge 0x2685
movl %ebx, %ebx
movq %rdi, %r12
leaq (%rdi,%rbx,4), %rdi
movslq %r14d, %r15
leaq (%r8,%r15,4), %rsi
notl %r14d
addl %ebp, %r14d
leaq 0x4(,%r14,4), %rdx
callq 0x21b0
movslq %ebp, %rax
subq %rax, %r15
xorl %eax, %eax
decq %rax
cmpq %rax, %r15
jne 0x2678
subl %eax, %ebx
movq %r12, %rdi
movq 0x20(%rsp), %rax
movl %ebx, (%rax)
movq %rdi, %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/Bazar.c
// Function: UnionListesTriees2
int UnionListesTriees2(int * const L1, const int t1, int * const L2, const int t2, int * const Final)
{
	int i=0, j=0, cpt=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]<L2[j]) Final[cpt++]=L1[i++];
		else
		{
			if (L1[i]==L2[j]) i++;
			Final[cpt++]=L2[j++];
		}
	}
	for (i = i; i < t1; i++) Final[cpt++]=L1[i];
	for (j = j; j < t2; j++) Final[cpt++]=L2[j];
	return cpt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
testl %esi, %esi
setle %al
testl %ecx, %ecx
setle %r9b
xorl %r10d, %r10d
orb %al, %r9b
movl $0x0, %r9d
movl $0x0, %eax
jne 0x270a
xorl %eax, %eax
movl $0x1, %r11d
xorl %r9d, %r9d
xorl %r10d, %r10d
movslq %r10d, %r10
movl (%rdi,%r10,4), %ebx
movslq %r9d, %r14
movl (%rdx,%r14,4), %ebp
leal 0x1(%r14), %r9d
xorl %r15d, %r15d
cmpl %ebp, %ebx
sete %r15b
cmovll %ebx, %ebp
cmovll %r11d, %r15d
cmovll %r14d, %r9d
addl %r15d, %r10d
movl %ebp, (%r8,%rax,4)
incq %rax
cmpl %esi, %r10d
jge 0x270a
cmpl %ecx, %r9d
jl 0x26d0
cmpl %esi, %r10d
jge 0x2736
movl %eax, %eax
movslq %r10d, %r11
movslq %esi, %rsi
leaq (%rdi,%r11,4), %r10
subq %r11, %rsi
leaq (%r8,%rax,4), %r11
xorl %edi, %edi
movl (%r10,%rdi,4), %ebx
movl %ebx, (%r11,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x2724
addl %edi, %eax
cmpl %ecx, %r9d
jge 0x2762
movl %eax, %eax
movslq %r9d, %rdi
movslq %ecx, %rcx
leaq (%rdx,%rdi,4), %rsi
subq %rdi, %rcx
leaq (%r8,%rax,4), %rdi
xorl %edx, %edx
movl (%rsi,%rdx,4), %r8d
movl %r8d, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2750
addl %edx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: OrdreListe_tmp
int OrdreListe_tmp(int * const L1, const int t1, int * const L2, const int t2)
{
	if (t1==0)
	{
		if (t2==0) return 0;
		else return 1;
	}
	if (*L1<*L2) return 1;
	if (*L1>*L2) return -1;
	return OrdreListe_tmp(L1+1,t1-1,L2+1,t2-1);
}

// Assembly:
movl %esi, %eax
xorl %esi, %esi
cmpl %esi, %eax
je 0x2782
movl (%rdx,%rsi,4), %r8d
cmpl %r8d, (%rdi,%rsi,4)
jl 0x278a
jg 0x2790
incq %rsi
jmp 0x276d
xorl %eax, %eax
cmpl %esi, %ecx
setne %al
retq
movl $0x1, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: IntersectionListesTriees
int * IntersectionListesTriees(int * const L1, const int t1, int * const L2, const int t2, int *taille)
{
	int * __restrict Final=malloc(max(min(t1,t2),0)*sizeof(int));
	int i=0, j=0, cpt=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]<L2[j]) i++;
		else
		{
			if (L1[i]==L2[j]) Final[cpt++]=L1[i++];
			j++;
		}
	}
	*taille=cpt;
	return Final;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
leaq (,%rax,4), %rdi
xorl %r13d, %r13d
testl %eax, %eax
cmovleq %r13, %rdi
callq 0x21d0
testl %r15d, %r15d
setle %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0x2835
xorl %r13d, %r13d
xorl %ecx, %ecx
xorl %edx, %edx
movslq %edx, %rsi
movl (%r12,%rsi,4), %esi
movslq %ecx, %rdi
cmpl (%r14,%rdi,4), %esi
jge 0x281d
incl %edx
jmp 0x282c
jne 0x282a
incl %edx
movslq %r13d, %rdi
incl %r13d
movl %esi, (%rax,%rdi,4)
incl %ecx
cmpl %r15d, %edx
jge 0x2835
cmpl %ebp, %ecx
jl 0x2809
movl %r13d, (%rbx)
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/Bazar.c
// Function: DifferenceListesTriees
int * DifferenceListesTriees(int * const L1, const int t1, int * const L2, const int t2, int *taille) /* L1 - L2 */
{
	int * __restrict Final=malloc(max(t1,0)*sizeof(int));
	int i=0, j=0, cpt=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]<L2[j]) Final[cpt++]=L1[i++];
		else
		{
			if (L1[i]==L2[j]) i++;
			j++;
		}
	}
	for (j = i; j < t1; j++) Final[cpt++]=L1[j];
	*taille=cpt;
	return Final;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r15
xorl %ebx, %ebx
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
setle 0xf(%rsp)
shlq $0x2, %rdi
callq 0x21d0
movq %rax, %r14
testl %r12d, %r12d
setle %al
orb 0xf(%rsp), %al
movl $0x0, %eax
jne 0x28ca
xorl %eax, %eax
xorl %ecx, %ecx
xorl %ebx, %ebx
movslq %ebx, %rdx
movl (%r15,%rdx,4), %edx
movslq %ecx, %rsi
cmpl (%r13,%rsi,4), %edx
jge 0x28b7
incl %ebx
movslq %eax, %rsi
incl %eax
movl %edx, (%r14,%rsi,4)
jmp 0x28c1
sete %dl
movzbl %dl, %edx
addl %edx, %ebx
incl %ecx
cmpl %ebp, %ebx
jge 0x28ca
cmpl %r12d, %ecx
jl 0x2899
cmpl %ebp, %ebx
jge 0x2902
movslq %eax, %r13
leaq (%r14,%r13,4), %rdi
movslq %ebx, %r12
leaq (%r15,%r12,4), %rsi
notl %ebx
addl %ebp, %ebx
leaq 0x4(,%rbx,4), %rdx
callq 0x21b0
movl %r13d, %eax
movslq %ebp, %rcx
subq %rcx, %r12
xorl %ecx, %ecx
decq %rcx
cmpq %rcx, %r12
jne 0x28f8
subl %ecx, %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
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/Bazar.c
// Function: Tri_tmp
void Tri_tmp(int *L1, int taille, int *L)
{
	int N1=taille/2;
	if (N1>2) Tri_tmp(L1,N1,L);
	if (taille-N1>2) Tri_tmp(L1+N1,taille-N1,L);
	int i;
	for (i = 0; i < N1; i++) L[i]=L1[i];
	i=0;
	int j=N1, cpt=0;
	while (i<N1 && j<taille)
	{
		if (L[i]<L1[j]) L1[cpt++]=L[i++];
		else
		{
			if (L[i]>L1[j]) L1[cpt++]=L1[j++];
			else L1[cpt++]=L[i++];
		}
	}
	for (j = i; j < N1; j++) L1[cpt++]=L[j];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x1f, %ebp
addl %esi, %ebp
sarl %ebp
cmpl $0x6, %esi
jl 0x2990
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2964
movl %r15d, %esi
subl %ebp, %esi
movslq %ebp, %r12
cmpl $0x3, %esi
jl 0x29a9
leaq (%rbx,%r12,4), %rdi
movq %r14, %rdx
callq 0x2964
cmpl $0x2, %r15d
jl 0x29c2
movl %ebp, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x29b3
cmpl $0x2, %r15d
jl 0x29fc
xorl %ecx, %ecx
movl %ebp, %edx
xorl %eax, %eax
movslq %eax, %rsi
movl (%r14,%rsi,4), %esi
movslq %edx, %rdi
movl (%rbx,%rdi,4), %edi
cmpl %edi, %esi
jl 0x29e7
jle 0x29e7
incl %edx
movl %edi, %esi
jmp 0x29e9
incl %eax
movl %esi, (%rbx,%rcx,4)
incq %rcx
cmpl %ebp, %eax
jge 0x29f8
cmpl %r15d, %edx
jl 0x29ce
movl %ecx, %ecx
jmp 0x2a00
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %ebp, %eax
jge 0x2a22
movslq %eax, %rdx
leaq (%r14,%rdx,4), %rax
subq %rdx, %r12
leaq (%rbx,%rcx,4), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r12
jne 0x2a14
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: TriSpecial_tmp
void TriSpecial_tmp(int *L1, int *L2, int taille, int *L)
{
	int N1=taille/2;
	if (N1>2) TriSpecial_tmp(L1,L2,N1,L);
	if (taille-N1>2) TriSpecial_tmp(L1+N1,L2,taille-N1,L);
	int i;
	for (i = 0; i < N1; i++) L[i]=L1[i];
	i=0;
	int j=N1, cpt=0;
	while (i<N1 && j<taille)
	{
		if (L2[L[i]]<L2[L1[j]]) L1[cpt++]=L[i++];
		else
		{
			if (L2[L[i]]>L2[L1[j]]) L1[cpt++]=L1[j++];
			else L1[cpt++]=L[i++];
		}
	}
	for (j = i; j < N1; j++) L1[cpt++]=L[j];	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl %edx, %ebp
shrl $0x1f, %ebp
addl %edx, %ebp
sarl %ebp
cmpl $0x6, %edx
jl 0x2ae2
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x2aad
movl %r15d, %edx
subl %ebp, %edx
movslq %ebp, %r13
cmpl $0x3, %edx
jl 0x2afe
leaq (%rbx,%r13,4), %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x2aad
cmpl $0x2, %r15d
jl 0x2b17
movl %ebp, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2b08
cmpl $0x2, %r15d
jl 0x2b58
xorl %ecx, %ecx
movl %ebp, %edx
xorl %eax, %eax
movslq %eax, %rsi
movslq (%r14,%rsi,4), %rsi
movslq %edx, %rdi
movslq (%rbx,%rdi,4), %rdi
movl (%r12,%rdi,4), %r8d
cmpl %r8d, (%r12,%rsi,4)
jl 0x2b43
jle 0x2b43
incl %edx
movl %edi, %esi
jmp 0x2b45
incl %eax
movl %esi, (%rbx,%rcx,4)
incq %rcx
cmpl %ebp, %eax
jge 0x2b54
cmpl %r15d, %edx
jl 0x2b23
movl %ecx, %ecx
jmp 0x2b5c
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %ebp, %eax
jge 0x2b7e
movslq %eax, %rdx
leaq (%r14,%rdx,4), %rax
subq %rdx, %r13
leaq (%rbx,%rcx,4), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r13
jne 0x2b70
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/Bazar.c
// Function: ContenuListesTriees_tmp
int ContenuListesTriees_tmp(int * const L1, const int t1, int * const L2, const int t2)
{
	if (t1!=t2)
	{
		const int i=t1 >> 1;
		const int j=SearchElement(L1[i],L2,t2);
		if (j==-1) return 0;
		else
		{
			const int t3=i+1;
			const int t4=j+1;
			return ContenuListesTriees_tmp2(L1,i,L2,j,L1+t3,t1-t3,L2+t4,t2-t4);
		}
	}
	else
	{
		int i;
		for (i = 0; i < t1; i++) if (L1[i]!=L2[i]) return 0;
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl %ecx, %esi
jne 0x2be1
movl $0x1, %eax
testl %esi, %esi
jle 0x2c64
movl %esi, %ecx
xorl %esi, %esi
movl (%rdi,%rsi,4), %r8d
cmpl (%rdx,%rsi,4), %r8d
jne 0x2c62
incq %rsi
cmpq %rsi, %rcx
jne 0x2bc6
jmp 0x2c64
movl %esi, %eax
sarl %eax
cltq
movl (%rdi,%rax,4), %r8d
xorl %r9d, %r9d
movl %ecx, %r11d
cmpl %r11d, %r9d
jge 0x2c20
leal (%r11,%r9), %ebx
shrl %ebx
leal 0x1(%rbx), %ebp
movl %r11d, %r14d
cmpl %r8d, (%rdx,%rbx,4)
cmovgl %ebx, %r14d
cmovgel %r9d, %ebp
cmovel %r11d, %r14d
cmovel %ebx, %r10d
movl %ebp, %r9d
movl %r14d, %r11d
jne 0x2bf1
jmp 0x2c26
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r10d
je 0x2c62
leaq (%rdi,%rax,4), %r8
addq $0x4, %r8
movl %eax, %r9d
notl %r9d
addl %esi, %r9d
movslq %r10d, %rsi
leaq (%rdx,%rsi,4), %r11
addq $0x4, %r11
movl %r10d, %ebx
notl %ebx
addl %ecx, %ebx
movl %eax, %esi
movl %r10d, %ecx
pushq %rbx
pushq %r11
callq 0x2c69
addq $0x10, %rsp
jmp 0x2c64
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: ContenuListesTriees_tmp2
int ContenuListesTriees_tmp2(int * const L1, const int t1, int * const L2, const int t2, int * const L3, const int t3, int * const L4, const int t4)
{
	if (t1<=0) return ContenuListesTriees(L3,t3,L4,t4);
	if (t3<=0) return ContenuListesTriees(L1,t1,L2,t2);
	if (t1<=t2 && t3<=t4) return (ContenuListesTriees_tmp(L1,t1,L2,t2) && ContenuListesTriees_tmp(L3,t3,L4,t4));
	else return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movq %r8, %r14
movl 0x38(%rsp), %ebp
movq 0x30(%rsp), %r15
testl %esi, %esi
jle 0x2ca6
testl %ebx, %ebx
jle 0x2cba
cmpl %ecx, %esi
setg %al
cmpl %ebp, %ebx
setg %r8b
xorl %r12d, %r12d
orb %al, %r8b
jne 0x2cd6
callq 0x2bad
testl %eax, %eax
jne 0x2cae
jmp 0x2cd6
testl %ebx, %ebx
jle 0x2cd0
cmpl %ebp, %ebx
jg 0x2cbe
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movl %ebp, %ecx
jmp 0x2cc3
cmpl %ecx, %esi
jle 0x2cc3
xorl %r12d, %r12d
jmp 0x2cd6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2bad
movl $0x1, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: IntersectionNonVideListeTriees
int IntersectionNonVideListeTriees(int * const L1, const int t1, int * const L2, const int t2)
{
	int i=0,j=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]==L2[j]) return 1;
		else
		{
			if (L1[i]<L2[j]) i++;
			else j++;
		}
	}
	return 0;
}

// Assembly:
testl %esi, %esi
setle %r8b
testl %ecx, %ecx
setle %r9b
xorl %eax, %eax
orb %r8b, %r9b
jne 0x2d40
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %r9d, %eax
movl %r8d, %r10d
movl (%rdx,%r10,4), %r10d
cmpl %r10d, (%rdi,%rax,4)
je 0x2d41
setge %r10b
setl %al
movzbl %al, %eax
addl %eax, %r9d
xorl %eax, %eax
cmpl %esi, %r9d
jge 0x2d40
movzbl %r10b, %r10d
addl %r10d, %r8d
cmpl %ecx, %r8d
jl 0x2d10
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: NextSet
int NextSet(int * X, int l, int n)
{
	int i;
	for (i = 1; i <= l; i++)
	{
		if (X[l-i]!=n-i)
		{
			int j;
			int add = ++X[l-i];
			for (j = l-i+1; j < l; j++) X[j] = ++add;
			return 1;
		}
	}
			
	for (i = 0; i < l; i++) X[i]=i;
	return 0;
}

// Assembly:
movl %esi, %ecx
testl %esi, %esi
jle 0x2db4
leal 0x1(%rsi), %r8d
decl %edx
leaq (%rdi,%rcx,4), %rax
addq $-0x4, %rax
movl $0x1, %r10d
subq %r8, %r10
xorl %r8d, %r8d
movl (%rax,%r8,4), %r9d
leal (%rdx,%r8), %r11d
cmpl %r9d, %r11d
jne 0x2dc9
decq %r8
cmpq %r8, %r10
jne 0x2d9f
xorl %eax, %eax
testl %esi, %esi
jle 0x2dff
xorl %edx, %edx
movl %edx, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2dbc
jmp 0x2dff
leaq (%rdi,%rcx,4), %rax
leal 0x1(%r9), %edx
movl %edx, -0x4(%rax,%r8,4)
addq %r8, %rcx
movl $0x1, %eax
cmpl %esi, %ecx
jge 0x2dff
negq %r8
movslq %ecx, %rcx
leaq (%rdi,%rcx,4), %rcx
addl $0x2, %r9d
movl %r9d, (%rcx)
addq $0x4, %rcx
incl %r9d
decl %r8d
jne 0x2df0
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Algebre.c
// Function: echangeligne
void echangeligne(int i, int j, unsigned char **mat, int a, int b) // Echange les lignes i et j de la matrice mat
{
	if (i<a && j<a)
	{
		unsigned char *tmp1=mat[i];
		mat[i]=mat[j];
		mat[j]=tmp1;
	}
}

// Assembly:
cmpl %ecx, %edi
setge %al
cmpl %ecx, %esi
setge %cl
orb %al, %cl
jne 0x2e24
movslq %edi, %rax
movq (%rdx,%rax,8), %rcx
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rdi
movq %rdi, (%rdx,%rax,8)
movq %rcx, (%rdx,%rsi,8)
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Algebre.c
// Function: echangecolonne
void echangecolonne(int i, int j, unsigned char **mat, int a, int b) // Echange les colonnes i et j de la matrice mat
{
	if (i<b && j<b)
	{
		int k;
		for (k = 0; k < a; k++)
		{
			unsigned char tmp=mat[k][i];
			mat[k][i]=mat[k][j];
			mat[k][j]=tmp;
		}
	}
}

// Assembly:
cmpl %r8d, %edi
setge %al
cmpl %r8d, %esi
setge %r8b
orb %al, %r8b
testl %ecx, %ecx
setle %al
orb %r8b, %al
jne 0x2e69
movslq %edi, %rax
movslq %esi, %rsi
movl %ecx, %ecx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movb (%r8,%rax), %r9b
movb (%r8,%rsi), %r10b
movb %r10b, (%r8,%rax)
movq (%rdx,%rdi,8), %r8
movb %r9b, (%r8,%rsi)
incq %rdi
cmpq %rdi, %rcx
jne 0x2e49
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Algebre.c
// Function: PrintMat
void PrintMat(unsigned char **mat, const int a, const int b) // Print la matrice mat de taille a x b 
{
	int i;
	for (i = 0; i < a; i++)
	{
		int j;
		for (j = 0; j < b; j++) printf("%02x ",mat[i][j]);
		printf("\n");
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
testl %esi, %esi
jle 0x2ec6
movq %rdi, %r14
movl %esi, %r12d
movl 0x4(%rsp), %r13d
leaq 0x26281(%rip), %r15     # 0x29110
xorl %ebp, %ebp
cmpl $0x0, 0x4(%rsp)
jle 0x2eb4
xorl %ebx, %ebx
movq (%r14,%rbp,8), %rax
movzbl (%rax,%rbx), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %rbx
cmpq %rbx, %r13
jne 0x2e9a
movl $0xa, %edi
callq 0x2040
incq %rbp
cmpq %r12, %rbp
jne 0x2e91
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Algebre.c
// Function: Dimension_tmp
int Dimension_tmp(unsigned char ** __restrict m, const int a, const int b) // calcul le rang de la matrice mat de taille a x b, ie la dimension de l'espace engendré par les b vecteurs colonnes.
{
	int dim = 0;
	int pivot_c;
	for (pivot_c = 0; pivot_c < b; pivot_c++)
	{
		int new_pivot_l;
		for (new_pivot_l = dim; new_pivot_l < a; new_pivot_l++)
		{
			if (m[new_pivot_l][pivot_c])
			{
				if (new_pivot_l!=dim)
				{
					unsigned char * __restrict const tmp = m[dim];
					m[dim]=m[new_pivot_l];
					m[new_pivot_l]=tmp;
				}

				const unsigned char * __restrict const ligne_pivot = m[dim];
				int ligne;
				for (ligne = new_pivot_l+1; ligne < a; ligne++) // on fait le pivot de Gauss
				{
					if (m[ligne][pivot_c])
					{
						int colonne;
						unsigned char * __restrict ligne_need_update = m[ligne];
						const unsigned char coeff = Multiply(Inverse(ligne_pivot[pivot_c]),ligne_need_update[pivot_c]);
						for (colonne = pivot_c+1; colonne < b; colonne++)
						{
							//m[ligne][colonne]=Multiply(m[dim][pivot_c],m[ligne][colonne]) ^ Multiply(m[ligne][pivot_c],m[dim][colonne]);
							ligne_need_update[colonne]^=Multiply(coeff,ligne_pivot[colonne]);
						}
					}
				}
				dim++;
				if (dim != a) break;
				else return dim;
			}
		}
	}
	return dim;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
testl %edx, %edx
jle 0x318a
movslq %esi, %rax
movq %rax, 0x30(%rsp)
movl %edx, %r13d
xorl %ebp, %ebp
movl $0x1, %r10d
leaq 0x15f93(%rip), %r15     # 0x19010
xorl %eax, %eax
movl %esi, 0x10(%rsp)
movb $0x1, %r11b
movl %esi, %edi
subl %eax, %edi
jle 0x3174
movslq %eax, %rcx
movq 0x8(%rsp), %rdx
leaq (%rdx,%rcx,8), %r9
xorl %edx, %edx
movq (%r9,%rdx,8), %r8
cmpb $0x0, (%r8,%rbp)
jne 0x30b5
incq %rdx
cmpl %edx, %edi
jne 0x309e
jmp 0x3174
movl %ebx, 0x14(%rsp)
movq %r10, 0x20(%rsp)
testl %edx, %edx
je 0x30d3
movq 0x8(%rsp), %rdi
movq (%rdi,%rcx,8), %r10
movq %r8, (%rdi,%rcx,8)
movq %r10, (%r9,%rdx,8)
movl %eax, %edi
incl %eax
movq %rax, 0x18(%rsp)
leal (%rdi,%rdx), %eax
incl %eax
cmpl %esi, %eax
jge 0x3159
addq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax,%rcx,8), %r12
leaq 0x1(%rbp), %rax
movq %rax, 0x28(%rsp)
movslq %edx, %r14
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rbx
cmpb $0x0, (%rbx,%rbp)
je 0x314f
movzbl (%r12,%rbp), %edi
callq 0x2537
cmpq %r13, 0x28(%rsp)
jae 0x314f
movzbl (%rbx,%rbp), %ecx
movzbl %al, %eax
shll $0x8, %eax
addq %r15, %rax
movzbl (%rcx,%rax), %eax
shll $0x8, %eax
movq 0x20(%rsp), %rcx
movzbl (%r12,%rcx), %edx
leaq (%rax,%r15), %rsi
movb (%rdx,%rsi), %dl
xorb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %r13
jne 0x3138
incq %r14
cmpq 0x30(%rsp), %r14
jl 0x30ff
movl 0x10(%rsp), %esi
movq 0x18(%rsp), %rax
cmpl %esi, %eax
setne %r11b
movl 0x14(%rsp), %ebx
cmovel %eax, %ebx
movq 0x20(%rsp), %r10
testb %r11b, %r11b
je 0x318e
incq %rbp
incq %r10
cmpq %r13, %rbp
jne 0x3083
jmp 0x3190
xorl %eax, %eax
jmp 0x3190
movl %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/Algebre.c
// Function: Dimension
int Dimension(unsigned char ** __restrict mat, const int a, const int b, const int copy) // calcul le rang de la matrice mat de taille a x b, ie la dimension de l'espace engendré par les b vecteurs colonnes.
{
	if (!copy) return Dimension_tmp(mat,a,b); // Attention : la matrice mat sera modifiée, aucune propriété conservée !!
	else
	{
		unsigned char ** __restrict m=malloc(a*sizeof(unsigned char *));
		unsigned char * __restrict espace=malloc(a*b*sizeof(unsigned char));
		int i;
		for (i = 0; i < a; i++)
		{
			m[i]=espace+i*b;
			int j;
			for (j = 0; j < b; j++) m[i][j]=mat[i][j];
		}
		int dim = Dimension_tmp(m,a,b);
		free(m);
		free(espace);
		return dim;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x3250
movslq %ebp, %r13
leaq (,%r13,8), %rdi
callq 0x21d0
movq %rax, %r15
movl %ebx, %eax
imull %ebp, %eax
movslq %eax, %rdi
callq 0x21d0
movq %rax, %r12
testl %r13d, %r13d
jle 0x3221
movslq %ebx, %rax
movl %ebp, %ecx
movl %eax, %edx
xorl %esi, %esi
movq %r12, %rdi
movq %rsi, %r8
imulq %rax, %r8
addq %r12, %r8
movq %r8, (%r15,%rsi,8)
testl %eax, %eax
jle 0x3216
movq (%r14,%rsi,8), %r8
xorl %r9d, %r9d
movb (%r8,%r9), %r10b
movb %r10b, (%rdi,%r9)
incq %r9
cmpq %r9, %rdx
jne 0x3206
incq %rsi
addq %rax, %rdi
cmpq %rcx, %rsi
jne 0x31ed
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3048
movl %eax, %ebx
movq %r15, %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3048
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Algebre.c
// Function: Somme
int Somme(unsigned char **dst, unsigned char **mat1, int b1, unsigned char **mat2, int a, int b2) // Renvoie une base de <mat1> + <mat2>
{
	unsigned char ** __restrict m=malloc(a*sizeof(unsigned char *));
	int b=b1+b2, i;
	for (i = 0; i < a; i++)
	{
		m[i]=malloc(b*sizeof(unsigned char));
		int j;
		for (j = 0; j < b1; j++) m[i][j]=mat1[i][j];
		for (j = 0; j < b2; j++) m[i][j+b1]=mat2[i][j];	
	}
	b=Base(dst,m,a,b);
	for (i = 0; i < a; i++) free(m[i]);
	free(m);
	return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, 0x30(%rsp)
movl %edx, %r12d
movq %rsi, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
movslq %r8d, %r14
leaq (,%r14,8), %rdi
callq 0x21d0
movq %rax, %rbx
movq %r15, 0x10(%rsp)
movq %r12, 0x8(%rsp)
leal (%r15,%r12), %eax
movl %eax, (%rsp)
movl %ebp, 0x4(%rsp)
movl %ebp, %r15d
testl %r14d, %r14d
jle 0x3888
movslq (%rsp), %rbp
movslq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl %eax, %r12d
movl 0x10(%rsp), %r14d
xorl %r13d, %r13d
movq %rbp, %rdi
callq 0x21d0
movq %rax, (%rbx,%r13,8)
cmpl $0x0, 0x8(%rsp)
jle 0x3859
movq 0x28(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r12
jne 0x3849
cmpl $0x0, 0x10(%rsp)
jle 0x3880
movq 0x30(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
addq 0x20(%rsp), %rax
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r14
jne 0x3870
incq %r13
cmpq %r15, %r13
jne 0x382b
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl 0x4(%rsp), %r14d
movl %r14d, %edx
movl (%rsp), %ecx
callq 0x326a
movl %eax, %ebp
testl %r14d, %r14d
jle 0x38bb
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x2030
incq %r14
cmpq %r14, %r15
jne 0x38aa
movq %rbx, %rdi
callq 0x2030
movl %ebp, %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/Algebre.c
// Function: Supplementaire
int Supplementaire(unsigned char **dst, unsigned char **mat1, int b1, unsigned char **mat2, int a, int b2) // Renvoie une base d'un supplémentaire de <mat1> dans <mat2>
{
	#if 0 // A activer si problème
	unsigned char **m1,**m2,**m3;
	int i,b3,b;
	m1=malloc(a*sizeof(unsigned char *));
	for (i = 0; i < a; i++) m1[i]=malloc(b1*sizeof(unsigned char));
	m2=malloc(a*sizeof(unsigned char *));
	for (i = 0; i < a; i++) m2[i]=malloc(b2*sizeof(unsigned char)); 
	b1=Base(m1,mat1,a,b1);
	b2=Base(m2,mat2,a,b2);
	m3=malloc(a*sizeof(unsigned char *));
	for (i = 0; i < a; i++) m3[i]=malloc(max(b1,b2)*sizeof(unsigned char));
	b3=Supplementaire_tmp(m3,m1,b1,m2,a,b2);
	b=Base(dst,m3,a,b3);
	for (i = 0; i < a; i++) free(m1[i]);
	free(m1);
	for (i = 0; i < a; i++) free(m2[i]);
	free(m2);
	for (i = 0; i < a; i++) free(m3[i]);
	free(m3);
	return b;
	#else
	unsigned char ** __restrict m3=malloc(a*sizeof(unsigned char *));
	int i;
	for (i = 0; i < a; i++) m3[i]=malloc(max(b1,b2)*sizeof(unsigned char));
	int b3=Supplementaire_tmp(m3,mat1,b1,mat2,a,b2);
	int b=Base(dst,m3,a,b3);
	for (i = 0; i < a; i++) free(m3[i]);
	free(m3);
	return b;
	#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %ebp
movq %rcx, 0x18(%rsp)
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movslq %r8d, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %rbx
movl %ebp, %r14d
testl %r15d, %r15d
jle 0x3e2d
movl 0xc(%rsp), %eax
cmpl %eax, %r13d
cmovgl %r13d, %eax
movslq %eax, %r12
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x21d0
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x3e19
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x38d4
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x326a
movl %eax, %r15d
testl %ebp, %ebp
jle 0x3e76
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x2030
incq %r12
cmpq %r12, %r14
jne 0x3e65
movq %rbx, %rdi
callq 0x2030
movl %r15d, %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/Algebre.c
// Function: Intersection
int Intersection(unsigned char **dst, unsigned char **mat1, int b1, unsigned char **mat2, int a, int b2) // Renvoie une base de <mat1> n <mat2>
{
	#if 0 // A activer si problème
	unsigned char **m1,**m2,**m3;
	int i,b3,b;
	m1=malloc(a*sizeof(unsigned char *));
	for (i = 0; i < a; i++) m1[i]=malloc(b1*sizeof(unsigned char));
	m2=malloc(a*sizeof(unsigned char *));
	for (i = 0; i < a; i++) m2[i]=malloc(b2*sizeof(unsigned char)); 
	b1=Base(m1,mat1,a,b1);
	b2=Base(m2,mat2,a,b2);
	m3=malloc(a*sizeof(unsigned char *));
	for (i = 0; i < a; i++) m3[i]=malloc(max(b1,b2)*sizeof(unsigned char));
	b3=Intersection_tmp(m3,m1,b1,m2,a,b2);
	b=Base(dst,m3,a,b3);
	for (i = 0; i < a; i++) free(m1[i]);
	free(m1);
	for (i = 0; i < a; i++) free(m2[i]);
	free(m2);
	for (i = 0; i < a; i++) free(m3[i]);
	free(m3);
	return b;
	#else
	unsigned char **m3=malloc(a*sizeof(unsigned char *));
	int i;
	for (i = 0; i < a; i++) m3[i]=malloc(max(b1,b2)*sizeof(unsigned char));
	int b3=Intersection_tmp(m3,mat1,b1,mat2,a,b2);
	int b=Base(dst,m3,a,b3);
	for (i = 0; i < a; i++) free(m3[i]);
	free(m3);
	return b;
	#endif
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %ebp
movq %rcx, 0x18(%rsp)
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movslq %r8d, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %rbx
movl %ebp, %r14d
testl %r15d, %r15d
jle 0x452a
movl 0xc(%rsp), %eax
cmpl %eax, %r13d
cmovgl %r13d, %eax
movslq %eax, %r12
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x21d0
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x4516
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x3e90
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x326a
movl %eax, %r15d
testl %ebp, %ebp
jle 0x4573
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x2030
incq %r12
cmpq %r12, %r14
jne 0x4562
movq %rbx, %rdi
callq 0x2030
movl %r15d, %eax
addq $0x28, %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/Equation.c
// Function: PrintEquationWithNames
void PrintEquationWithNames(Equation a, string_list_t *names)
{
  int i;
  for (i = 0; i < a->nV; i++)
    {
      if (i!=0) printf(" + ");
      
      if (a->var[i] == 0) 
	printf("%02x",a->coefV[i]);
      else {
	if (a->coefV[i] != 0x01) printf("%02x*",a->coefV[i]);
	printf("%s", find_var_name(names, a->var[i]));
      }
    }
  if (a->nV!=0 && a->nS!=0) printf(" + ");

  for (i = 0; i < a->nS; i++)
    {
      if (i!=0) printf(" + ");
      if (a->coefS[i] != 0x01) printf("%02x*",a->coefS[i]);
      if (a->sbox[i]) printf("R(");
      else printf("S(");
      PrintEquationWithNames(a->S[i], names);
      printf(")");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
testl %eax, %eax
jle 0x4636
leaq 0x24b68(%rip), %r15     # 0x2911a
leaq 0x24b6c(%rip), %r12     # 0x29125
leaq 0x24b56(%rip), %rbp     # 0x29116
xorl %r13d, %r13d
testq %r13, %r13
je 0x45d2
movq %rbp, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x8(%r14), %rax
cmpl $0x0, (%rax,%r13,4)
je 0x4618
movq 0x10(%r14), %rax
movzbl (%rax,%r13), %esi
cmpl $0x1, %esi
je 0x45f9
leaq 0x24b2d(%rip), %rdi     # 0x2911f
xorl %eax, %eax
callq 0x2110
movq 0x8(%r14), %rax
movl (%rax,%r13,4), %esi
movq %rbx, %rdi
callq 0xced1
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2110
jmp 0x462b
movq 0x10(%r14), %rax
movzbl (%rax,%r13), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x45c3
testl %eax, %eax
je 0x464f
cmpl $0x0, 0x18(%r14)
je 0x464f
leaq 0x24ace(%rip), %rdi     # 0x29116
xorl %eax, %eax
callq 0x2110
cmpl $0x0, 0x18(%r14)
jle 0x46d4
leaq 0x24ace(%rip), %r13     # 0x2912b
leaq 0x24abb(%rip), %r15     # 0x2911f
leaq 0x24aab(%rip), %r12     # 0x29116
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x467c
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x28(%r14), %rax
movzbl (%rax,%rbp), %esi
cmpl $0x1, %esi
je 0x4693
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x30(%r14), %rax
cmpb $0x0, (%rax,%rbp)
movq %r13, %rdi
je 0x46a7
leaq 0x24a81(%rip), %rdi     # 0x29128
xorl %eax, %eax
callq 0x2110
movq 0x20(%r14), %rax
movq (%rax,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x4590
movl $0x29, %edi
callq 0x2040
incq %rbp
movslq 0x18(%r14), %rax
cmpq %rax, %rbp
jl 0x466d
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: PrintEq
void PrintEq(Equation a)
{
  int i;
  for (i = 0; i < a->nV; i++)
    {
      if (i!=0) printf(" + ");
      
      if (a->coefV[i] != 0x01) printf("%02x*",a->coefV[i]);
      printf("x[%u]",a->var[i]);
      /*if (a->coefV[i]!=0x01) printf(")");*/
    }
  if (a->nV!=0 && a->nS!=0) printf(" + ");
  for (i = 0; i < a->nS; i++)
    {
      if (i!=0) printf(" + ");
      if (a->coefS[i]!=0x01) printf("%02x*",a->coefS[i]);
      if (a->sbox[i]) printf("R(");
      else printf("S(");
      PrintEq(a->S[i]);
      printf(")");
      if (a->coefS[i]!=0x01) printf(")");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
jle 0x4753
leaq 0x24a30(%rip), %r14     # 0x2912e
leaq 0x24a1a(%rip), %r15     # 0x2911f
leaq 0x24a0a(%rip), %r12     # 0x29116
xorl %r13d, %r13d
testq %r13, %r13
je 0x471e
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x10(%rbx), %rax
movzbl (%rax,%r13), %esi
cmpl $0x1, %esi
je 0x4736
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x8(%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
incq %r13
movslq (%rbx), %rax
cmpq %rax, %r13
jl 0x470f
testl %eax, %eax
je 0x476b
cmpl $0x0, 0x18(%rbx)
je 0x476b
leaq 0x249b2(%rip), %rdi     # 0x29116
xorl %eax, %eax
callq 0x2110
cmpl $0x0, 0x18(%rbx)
jle 0x4807
leaq 0x249af(%rip), %r12     # 0x2912b
leaq 0x249a5(%rip), %r13     # 0x29128
leaq 0x24995(%rip), %r14     # 0x2911f
leaq 0x24985(%rip), %r15     # 0x29116
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x47a2
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x28(%rbx), %rax
movzbl (%rax,%rbp), %esi
cmpl $0x1, %esi
je 0x47b9
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x30(%rbx), %rax
cmpb $0x0, (%rax,%rbp)
movq %r12, %rdi
je 0x47c9
movq %r13, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rax
movq (%rax,%rbp,8), %rdi
callq 0x46e3
movl $0x29, %edi
callq 0x2040
movq 0x28(%rbx), %rax
cmpb $0x1, (%rax,%rbp)
je 0x47fb
movl $0x29, %edi
callq 0x2040
incq %rbp
movslq 0x18(%rbx), %rax
cmpq %rax, %rbp
jl 0x4793
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: NulEq
Equation NulEq(void)
{
	Equation p=malloc(sizeof(EQUATION));
	p->nV=0;
	p->nS=0;
	p->var=NULL;
	p->coefV=NULL;
	p->coefS=NULL;
	p->sbox=NULL;
	p->S=NULL;
	return p;
}

// Assembly:
pushq %rax
movl $0x38, %edi
callq 0x21d0
xorl %ecx, %ecx
movl %ecx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ecx, 0x18(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Equation.c
// Function: freeEq
void freeEq(Equation a)
{
	int i;
	if (a!=NULL)
	{
		if (a->nV!=0)
		{
			free(a->var);
			free(a->coefV);
		}
		if (a->nS!=0)
		{
			for (i = 0; i < a->nS; i++) freeEq(a->S[i]);
			free(a->coefS);
			free(a->sbox);
			free(a->S);
		}
		free(a);
		a=NULL;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x48c4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x4872
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
cmpl $0x0, 0x18(%rbx)
je 0x48b5
cmpl $0x0, 0x18(%rbx)
jle 0x489a
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x484f
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x4881
movq 0x28(%rbx), %rdi
callq 0x2030
movq 0x30(%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Equation.c
// Function: copyEq
Equation copyEq(Equation a)
{
	Equation p=malloc(sizeof(EQUATION));
	p->nS=a->nS;
	if (p->nS!=0)
	{
		p->S=malloc(p->nS*sizeof(Equation));
		p->sbox=malloc(p->nS*sizeof(unsigned char));
		p->coefS=malloc(p->nS*sizeof(unsigned char));
		int i;
		for (i = 0; i < p->nS; i++)
		{
			p->S[i]=copyEq(a->S[i]);
			p->coefS[i]=a->coefS[i];
			p->sbox[i]=a->sbox[i];
		}
	}
	else
	{
		p->S=NULL;
		p->sbox=NULL;
		p->coefS=NULL;
	}
	p->nV=a->nV;
	if (p->nV!=0)
	{
		p->var=malloc(p->nV*sizeof(int));
		p->coefV=malloc(p->nV*sizeof(unsigned char));
		int i;
		for (i = 0; i < p->nV; i++)
		{
			p->var[i]=a->var[i];
			p->coefV[i]=a->coefV[i];
		}
	}
	else
	{
		p->var=NULL;
		p->coefV=NULL;
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x38, %edi
callq 0x21d0
movq %rax, %rbx
movslq 0x18(%r14), %r15
movl %r15d, 0x18(%rax)
testq %r15, %r15
movq %rax, (%rsp)
je 0x495c
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %r12
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x21d0
movq %rax, %r13
movq %rax, 0x30(%rbx)
movq %r15, %rdi
callq 0x21d0
movq %rax, 0x28(%rbx)
testl %r15d, %r15d
jle 0x496b
movq %rax, %rbp
xorl %ebx, %ebx
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rdi
callq 0x48c5
movq %rax, (%r12,%rbx,8)
movq 0x28(%r14), %rax
movb (%rax,%rbx), %al
movb %al, (%rbp,%rbx)
movq 0x30(%r14), %rax
movb (%rax,%rbx), %al
movb %al, (%r13,%rbx)
incq %rbx
cmpq %rbx, %r15
jne 0x492a
jmp 0x496b
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq $0x0, 0x30(%rbx)
movslq (%r14), %r15
movq (%rsp), %rbx
movl %r15d, (%rbx)
testq %r15, %r15
je 0x49c2
leaq (,%r15,4), %rdi
callq 0x21d0
movq %rax, %r12
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x21d0
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0x49c9
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
xorl %esi, %esi
movl (%rcx,%rsi,4), %edi
movl %edi, (%r12,%rsi,4)
movb (%rdx,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
cmpq %rsi, %r15
jne 0x49a9
jmp 0x49c9
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%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/Equation.c
// Function: EgaleEq
int EgaleEq(Equation a, Equation b)
{
	int i,j,res;
	if (a->nV==b->nV && a->nS==b->nS)
	{
		for (i = 0; i < a->nV; i++)
		{
			res=0;
			for (j = 0; j < b->nV; j++)
			{
				if (a->var[i]==b->var[j])
				{
					res=(a->coefV[i]==b->coefV[j]);
					break;
				} 
			}
			if (!res) return 0;
		}
		for (i = 0; i < a->nS; i++)
		{
			res=0;
			for (j = 0; j < b->nS; j++)
			{
				if (a->sbox[i]==b->sbox[j] && EgaleEq(a->S[i],b->S[j]))
				{
					res=(a->coefS[i]==b->coefS[j]);
					break;
				}
			}
			if (!res) return 0;
		}
		return 1;
	}
	else return 0;
}

// Assembly:
movl (%rdi), %ecx
movl (%rsi), %edx
xorl %eax, %eax
cmpl %edx, %ecx
jne 0x4afb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movl 0x18(%rdi), %r15d
movl 0x18(%rsi), %ebp
cmpl %ebp, %r15d
jne 0x4aed
testl %ecx, %ecx
jle 0x4a59
testl %edx, %edx
jle 0x4aed
movq 0x8(%r13), %rbx
movq 0x8(%rsi), %rdi
xorl %r8d, %r8d
movl (%rbx,%r8,4), %r10d
xorl %r9d, %r9d
cmpl (%rdi,%r9,4), %r10d
je 0x4a3b
incq %r9
cmpq %r9, %rdx
jne 0x4a28
jmp 0x4aeb
movq 0x10(%r13), %r10
movb (%r10,%r8), %r10b
movq 0x10(%rsi), %r11
cmpb (%r11,%r9), %r10b
jne 0x4aeb
incq %r8
cmpq %rcx, %r8
jne 0x4a21
testl %r15d, %r15d
jle 0x4ae4
testl %ebp, %ebp
jle 0x4aed
movq 0x30(%r13), %rax
movq 0x30(%rsi), %rbx
xorl %edx, %edx
movq %r15, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movb (%rax,%rdx), %al
xorl %r15d, %r15d
movb %al, 0x7(%rsp)
cmpb (%rbx,%r15), %al
jne 0x4ab7
movq 0x20(%r13), %rax
movq (%rax,%rdx,8), %rdi
movq 0x20(%rsi), %rax
movq %rsi, %r14
movq (%rax,%r15,8), %rsi
movq %rdx, %r12
callq 0x49db
movq %r14, %rsi
movq %r12, %rdx
testl %eax, %eax
movb 0x7(%rsp), %al
jne 0x4ac1
incq %r15
cmpq %r15, %rbp
jne 0x4a88
jmp 0x4aeb
movq 0x28(%r13), %rax
movb (%rax,%rdx), %al
movq 0x28(%rsi), %rcx
cmpb (%rcx,%r15), %al
jne 0x4aeb
incq %rdx
movq 0x10(%rsp), %r15
cmpq %r15, %rdx
movq 0x8(%rsp), %rax
jne 0x4a7e
movl $0x1, %eax
jmp 0x4aed
xorl %eax, %eax
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/Equation.c
// Function: varEq
Equation varEq(int i)
{
	Equation p=malloc(sizeof(EQUATION));
	if (p==NULL)
	{
		printf("ERROR!!");
		getchar();
	}
	p->nV=1;
	p->var=malloc(sizeof(int));
	if (p->var==NULL)
	{
		printf("ERROR!!");
		getchar();
	}
	p->coefV=malloc(sizeof(unsigned char));
	if (p->coefV==NULL)
	{
		printf("ERROR!!");
		getchar();
	}
	p->var[0]=i;
	p->coefV[0]=0x01;
	p->nS=0;
	p->S=NULL;
	p->coefS=NULL;
	p->sbox=NULL;
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x38, %edi
callq 0x21d0
movq %rax, %rbx
testq %rax, %rax
jne 0x4b2a
leaq 0x24616(%rip), %rdi     # 0x29134
xorl %eax, %eax
callq 0x2110
callq 0x2180
movl $0x1, (%rbx)
movl $0x4, %edi
callq 0x21d0
movq %rax, %r14
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x4b59
leaq 0x245e7(%rip), %rdi     # 0x29134
xorl %eax, %eax
callq 0x2110
callq 0x2180
movl $0x1, %edi
callq 0x21d0
movq %rax, %r15
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x4b82
leaq 0x245be(%rip), %rdi     # 0x29134
xorl %eax, %eax
callq 0x2110
callq 0x2180
movl %ebp, (%r14)
movb $0x1, (%r15)
movl $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq $0x0, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Equation.c
// Function: mulEq
Equation mulEq(unsigned char m, Equation a)
{
	if (m==0) return NulEq();
	Equation p=malloc(sizeof(EQUATION));
	p->nV=a->nV;
	p->nS=a->nS;
	if (p->nV>0)
	{
		p->var=malloc(p->nV*sizeof(int));
		p->coefV=malloc(p->nV*sizeof(unsigned char));
		int i;
		for (i = 0; i < p->nV; i++)
		{
			p->var[i]=a->var[i];
			p->coefV[i]=Multiply(a->coefV[i],m);
		}
	}
	else
	{
		p->var=NULL;
		p->coefV=NULL;
	}
	if (p->nS>0)
	{
		p->S=malloc(p->nS*sizeof(Equation));
		p->sbox=malloc(p->nS*sizeof(unsigned char));
		p->coefS=malloc(p->nS*sizeof(unsigned char));
		int i;
		for (i = 0; i < p->nS; i++)
		{
			p->sbox[i]=a->sbox[i];
			p->coefS[i]=Multiply(a->coefS[i],m);
			p->S[i]=copyEq(a->S[i]);
		}
	}
	else
	{
		p->S=NULL;
		p->coefS=NULL;
		p->sbox=NULL;
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
movl $0x38, %edi
callq 0x21d0
movq %rax, %r15
testl %ebp, %ebp
movq %rax, 0x8(%rsp)
je 0x4c4b
movslq (%r14), %r12
movl %r12d, (%r15)
movl 0x18(%r14), %r9d
movl %r9d, 0x18(%r15)
movzbl %bpl, %ebx
testq %r12, %r12
jle 0x4c61
leaq (,%r12,4), %rdi
movq %r9, %rbp
callq 0x21d0
movq %rax, %r13
movq %rax, 0x8(%r15)
movq %r12, %rdi
callq 0x21d0
movq %rbp, %r9
movq %rax, 0x10(%r15)
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
xorl %esi, %esi
leaq 0x143ec(%rip), %rdi     # 0x19010
movl (%rcx,%rsi,4), %r8d
movl %r8d, (%r13,%rsi,4)
movzbl (%rdx,%rsi), %r8d
shll $0x8, %r8d
addq %rdi, %r8
movb (%rbx,%r8), %r8b
movb %r8b, (%rax,%rsi)
incq %rsi
cmpq %rsi, %r12
jne 0x4c24
jmp 0x4c69
xorl %eax, %eax
movl %eax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movl %eax, 0x18(%r15)
jmp 0x4cf7
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
testl %r9d, %r9d
jle 0x4cf7
leaq (,%r9,8), %rdi
movq %r9, %rbp
callq 0x21d0
movq %rax, 0x10(%rsp)
movq %rax, 0x20(%r15)
movq %rbp, %rdi
callq 0x21d0
movq %rax, %r13
movq %rax, 0x30(%r15)
movq %rbp, %r12
movq %rbp, %rdi
callq 0x21d0
movq %rax, %rbp
movq %rax, 0x28(%r15)
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movb (%rax,%r15), %al
movb %al, (%r13,%r15)
movq 0x28(%r14), %rax
movzbl (%rax,%r15), %eax
shll $0x8, %eax
addq 0x2d311(%rip), %rax     # 0x31fe0
movb (%rbx,%rax), %al
movb %al, (%rbp,%r15)
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x48c5
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r12
jne 0x4caf
jmp 0x4d07
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
movq 0x8(%rsp), %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/Equation.c
// Function: apparaitEq
int apparaitEq(Equation a, int b)
{
	int i,cpt=0;
	for (i = 0; i < a->nV; i++)
	{
		if (a->var[i]==b)
		{
			cpt++;
			break;
		}
	}
	for (i = 0; i < a->nS; i++) cpt+=apparaitEq(a->S[i],b);
	return cpt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq (%rdi), %rax
testq %rax, %rax
jle 0x5412
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpl %ebx, (%rcx,%rdx,4)
je 0x5416
incq %rdx
cmpq %rdx, %rax
jne 0x5405
xorl %ebp, %ebp
jmp 0x541b
movl $0x1, %ebp
movslq 0x18(%rdi), %r14
testq %r14, %r14
jle 0x5440
movq 0x20(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movl %ebx, %esi
callq 0x53ed
addl %eax, %ebp
incq %r12
cmpq %r12, %r14
jne 0x542b
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
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, 0x20(%r14)
movl $0x1, %edi
callq 0x21d0
movq %rax, 0x28(%r14)
movl $0x1, %edi
callq 0x21d0
movq %rax, 0x30(%r14)
movq %r15, %rdi
callq 0x48c5
movq 0x20(%r14), %rcx
movq %rax, (%rcx)
movq 0x28(%r14), %rax
movb $0x1, (%rax)
movq 0x30(%r14), %rax
movb %bl, (%rax)
movq %r14, %rdi
callq 0x4d1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x484f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x54fd
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpl %ebx, (%rcx,%rdx,4)
je 0x5528
incq %rdx
cmpq %rdx, %rax
jne 0x54f0
movslq 0x18(%rdi), %r14
testq %r14, %r14
jle 0x5524
movq 0x20(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movl %ebx, %esi
callq 0x54d8
testl %eax, %eax
jne 0x5528
incq %r12
cmpq %r12, %r14
jne 0x550d
xorl %eax, %eax
jmp 0x552d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq