LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: srealloc
void* srealloc(void* ptr, size_t size, const char* fmt, ...)
{
    if (size <= 0)
        return ptr;

    void*   buf = NULL;

    va_list args;

    if ((buf = realloc(ptr, size)) == NULL) {
        if (fmt != NULL) {
            va_start(args, fmt);
            vfprintf(stderr, fmt, args);
            va_end(args);
        } else {
            fprintf(stderr, "%s: %d: neo_realloc(): %s\n",
                    __FILE__, __LINE__, strerror(errno));
        }
        if (ptr != NULL)
            free(ptr);

        return NULL;
    }

    return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x12bd
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x12d8
movq %rdx, %r15
movq %rbx, %rdi
callq 0x1070
movq %rax, %r14
testq %rax, %rax
je 0x12e8
movq %r14, %rbx
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %r15, %r15
jne 0x1323
movq 0x2d04(%rip), %rax      # 0x3ff8
movq (%rax), %r15
callq 0x1040
movl (%rax), %edi
callq 0x1090
leaq 0xd19(%rip), %rsi       # 0x2023
leaq 0xd09(%rip), %rdx       # 0x201a
pushq $0x3e
popq %rcx
movq %r15, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1060
jmp 0x135a
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq 0x2ca9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq %r15, %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1030
jmp 0x12d5
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: free2d
void free2d(char** buf, int y)
{
    int     i   = 0,
            j   = y - 1;

    while (i <= j) {
        if (*(buf + i) != NULL) {
            free(*(buf + i));
            *(buf + i) = NULL;
        }
        if (*(buf + j) != NULL) {
            free(*(buf + j));
            *(buf + j) = NULL;
        }
        i++;
        j--;
    }
    free(buf);

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
xorl %r15d, %r15d
cmpq %r14, %r15
jge 0x13aa
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x138d
callq 0x1030
andq $0x0, (%rbx,%r15,8)
movq -0x8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x13a2
callq 0x1030
andq $0x0, -0x8(%rbx,%r14,8)
incq %r15
decq %r14
jmp 0x1375
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x21c0
movq %rax, %rbx
xorl %r14d, %r14d
cmpq $0x100, %r14            # imm = 0x100
je 0x23bc
movl $0x100, %edi            # imm = 0x100
callq 0x21c0
movq %rax, (%rbx,%r14,8)
incq %r14
jmp 0x23a0
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x2428
movq %rax, %rcx
cmpq $0x100, %rcx            # imm = 0x100
je 0x2423
xorl %edx, %edx
movl %eax, %r8d
movl %ecx, %edi
movl %eax, %esi
andl $0xff, %esi
je 0x2410
andl $0x1, %r8d
movzbl %dil, %edi
cmovnel %edi, %r8d
xorb %r8b, %dl
leal (%rdi,%rdi), %r8d
movzbl %r8b, %r9d
xorb $0x1b, %r8b
testb %dil, %dil
movzbl %r8b, %edi
cmovnsl %r9d, %edi
shrl %esi
movl %esi, %r8d
jmp 0x23db
movq (%rbx,%rcx,8), %rsi
movb %dl, (%rsi,%rax)
movq (%rbx,%rax,8), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
jmp 0x23c9
incq %rax
jmp 0x23be
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
xorl %r13d, %r13d
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
addl %eax, %edi
shlq $0x2, %rdi
callq 0x21c0
xorl %edi, %edi
xorl %esi, %esi
movl %edi, %edx
movl %esi, %ecx
cmpl %r12d, %edi
jge 0x24b6
cmpl %ebp, %esi
jge 0x24b6
movl (%r15,%rdx,4), %r8d
movl (%r14,%rcx,4), %ecx
xorl %edi, %edi
xorl %r9d, %r9d
cmpl %ecx, %r8d
setle %dil
cmovll %r8d, %ecx
setge %r9b
addl %edx, %edi
movl %ecx, (%rax,%r13,4)
addl %r9d, %esi
incq %r13
jmp 0x247f
movslq %r12d, %rsi
cmpq %rsi, %rdx
jge 0x24ce
movl (%r15,%rdx,4), %edi
movl %edi, (%rax,%r13,4)
incq %r13
incq %rdx
jmp 0x24b9
movslq %ebp, %rdx
cmpq %rdx, %rcx
jge 0x24e6
movl (%r14,%rcx,4), %esi
movl %esi, (%rax,%r13,4)
incq %r13
incq %rcx
jmp 0x24d1
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_O2/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 %rbx
xorl %eax, %eax
xorl %r10d, %r10d
xorl %r9d, %r9d
movslq %r10d, %r11
cmpl %esi, %r10d
jge 0x253c
cmpl %ecx, %r9d
jge 0x253c
movl (%rdi,%r11,4), %r11d
movslq %r9d, %rbx
movl (%rdx,%rbx,4), %ebx
cmpl %ebx, %r11d
jge 0x2522
incl %r10d
jmp 0x2533
sete %r11b
movzbl %r11b, %r11d
addl %r11d, %r10d
incl %r9d
movl %ebx, %r11d
movl %r11d, (%r8,%rax,4)
incq %rax
jmp 0x2501
movslq %r9d, %r9
movslq %esi, %rsi
cmpq %rsi, %r11
jge 0x2557
movl (%rdi,%r11,4), %r10d
movl %r10d, (%r8,%rax,4)
incq %rax
incq %r11
jmp 0x2542
movslq %ecx, %rcx
cmpq %rcx, %r9
jge 0x256f
movl (%rdx,%r9,4), %esi
movl %esi, (%r8,%rax,4)
incq %rax
incq %r9
jmp 0x255a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %esi
xorl %r8d, %r8d
pushq $0x1
popq %rax
pushq $-0x1
popq %r9
cmpl %r8d, %esi
je 0x2593
movl (%rdx,%r8,4), %r10d
cmpl %r10d, (%rdi,%r8,4)
jl 0x259e
jg 0x259b
incq %r8
jmp 0x257d
xorl %eax, %eax
cmpl %esi, %ecx
setne %al
retq
movl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21c0
xorl %edx, %edx
xorl %ecx, %ecx
movl %edx, %edx
movslq %r13d, %r13
cmpl %r15d, %r13d
jge 0x262e
cmpl %ebp, %edx
jge 0x262e
movl (%r12,%r13,4), %esi
cmpl (%r14,%rdx,4), %esi
jge 0x261d
incq %r13
jmp 0x2605
jne 0x262a
incl %r13d
movslq %ecx, %rdi
incl %ecx
movl %esi, (%rax,%rdi,4)
incl %edx
jmp 0x2600
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
xorl %r13d, %r13d
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
shlq $0x2, %rdi
callq 0x21c0
xorl %edx, %edx
xorl %ecx, %ecx
movl %edx, %edx
movslq %r13d, %r13
movslq %ecx, %rcx
cmpl %r15d, %r13d
jge 0x26a7
cmpl %ebp, %edx
jge 0x26a7
movl (%r14,%r13,4), %esi
cmpl (%r12,%rdx,4), %esi
jge 0x2698
movl %esi, (%rax,%rcx,4)
incq %r13
incq %rcx
jmp 0x267a
sete %sil
movzbl %sil, %esi
addl %esi, %r13d
incl %edx
jmp 0x2672
movslq %r15d, %rdx
cmpq %rdx, %r13
jge 0x26be
movl (%r14,%r13,4), %esi
movl %esi, (%rax,%rcx,4)
incq %rcx
incq %r13
jmp 0x26aa
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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, %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x2
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
movl %eax, %r15d
cmpl $0x6, %esi
jl 0x2739
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x270b
movl %ebp, %esi
subl %r15d, %esi
movslq %r15d, %r12
cmpl $0x3, %esi
jl 0x2752
leaq (%r14,%r12,4), %rdi
movq %rbx, %rdx
callq 0x270b
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %rax, %rcx
je 0x2771
movl (%r14,%rax,4), %edx
movl %edx, (%rbx,%rax,4)
incq %rax
jmp 0x2760
xorl %ecx, %ecx
movq %r14, %rax
movl %r15d, %edx
movslq %ecx, %rsi
cmpl %r15d, %ecx
jge 0x27b1
cmpl %ebp, %edx
jge 0x27b1
movl (%rbx,%rsi,4), %esi
movslq %edx, %rdi
movl (%r14,%rdi,4), %edi
cmpl %edi, %esi
jl 0x279b
jle 0x279b
incl %edx
movl %edi, %esi
jmp 0x279d
incl %ecx
movl %esi, (%rax)
addq $0x4, %rax
jmp 0x2779
movl (%rbx,%rsi,4), %ecx
movl %ecx, (%rax)
incq %rsi
addq $0x4, %rax
cmpq %r12, %rsi
jl 0x27a5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %rcx
movl %edx, %eax
cltd
idivl %ecx
movl %eax, %r12d
cmpl $0x6, %ebp
jl 0x2876
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
callq 0x283f
movl %ebp, %edx
subl %r12d, %edx
movslq %r12d, %r13
cmpl $0x3, %edx
jl 0x2892
leaq (%r15,%r13,4), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x283f
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
cmpq %rax, %rcx
je 0x28b1
movl (%r15,%rax,4), %edx
movl %edx, (%rbx,%rax,4)
incq %rax
jmp 0x28a0
xorl %ecx, %ecx
movq %r15, %rax
movl %r12d, %edx
movslq %ecx, %rsi
cmpl %r12d, %ecx
jge 0x28f8
cmpl %ebp, %edx
jge 0x28f8
movslq (%rbx,%rsi,4), %rsi
movslq %edx, %rdi
movslq (%r15,%rdi,4), %rdi
movl (%r14,%rdi,4), %r8d
cmpl %r8d, (%r14,%rsi,4)
jl 0x28e2
jle 0x28e2
incl %edx
movl %edi, %esi
jmp 0x28e4
incl %ecx
movl %esi, (%rax)
addq $0x4, %rax
jmp 0x28b9
movl (%rbx,%rsi,4), %ecx
movl %ecx, (%rax)
incq %rsi
addq $0x4, %rax
cmpq %r13, %rsi
jl 0x28ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl %ecx, %esi
jne 0x2962
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
pushq $0x1
popq %rax
cmpq %rcx, %r15
je 0x29be
movl (%r14,%rcx,4), %edx
leaq 0x1(%rcx), %rsi
cmpl (%rbx,%rcx,4), %edx
movq %rsi, %rcx
je 0x294b
jmp 0x29bc
movl %ecx, %ebp
movl %r15d, %eax
sarl %eax
movslq %eax, %r12
movl (%r14,%r12,4), %edi
movq %rbx, %rsi
movl %ecx, %edx
callq 0x26cf
cmpl $-0x1, %eax
je 0x29bc
leaq (%r14,%r12,4), %r8
addq $0x4, %r8
movl %r12d, %r9d
notl %r9d
addl %r15d, %r9d
movslq %eax, %rcx
leaq (%rbx,%rcx,4), %r10
addq $0x4, %r10
movl %eax, %r11d
notl %r11d
addl %ebp, %r11d
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movl %eax, %ecx
pushq %r11
pushq %r10
callq 0x29c7
popq %rcx
popq %rdx
jmp 0x29be
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movl 0x38(%rsp), %ebp
movq 0x30(%rsp), %r15
testl %esi, %esi
jle 0x2a17
testl %ebx, %ebx
jle 0x2a21
cmpl %ecx, %esi
setg %al
cmpl %ebp, %ebx
setg %r8b
orb %al, %r8b
jne 0x2a30
callq 0x292a
testl %eax, %eax
je 0x2a30
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x292a
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a3d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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:
pushq %rbx
xorl %eax, %eax
movl $0x1, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl %esi, %r9d
jge 0x2a91
cmpl %ecx, %r10d
jge 0x2a91
movl %r9d, %r11d
movl %r10d, %ebx
movl (%rdx,%rbx,4), %ebx
cmpl %ebx, (%rdi,%r11,4)
je 0x2a8e
setge %r11b
setl %bl
movzbl %bl, %ebx
addl %ebx, %r9d
movzbl %r11b, %r11d
addl %r11d, %r10d
jmp 0x2a5f
movl %r8d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %esi, %rcx
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %esi, %r8d
leaq (%rdi,%rcx,4), %r10
cmpq %rax, %r8
je 0x2b1d
movl -0x4(%r10), %r9d
addq $-0x4, %r10
incq %rax
decl %edx
cmpl %r9d, %edx
je 0x2adf
leal 0x1(%r9), %edx
movl %edx, (%r10)
subl %eax, %esi
movslq %esi, %rdx
incq %rdx
addl $0x2, %r9d
pushq $0x1
popq %rax
cmpq %rcx, %rdx
jge 0x2b2e
movl %r9d, (%rdi,%rdx,4)
incq %rdx
incl %r9d
jmp 0x2b0c
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %r8
je 0x2b2e
movl %ecx, (%rdi,%rcx,4)
incq %rcx
jmp 0x2b21
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
jne 0x2b96
movslq %edi, %rax
movslq %esi, %rsi
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
cmpq %rdi, %rcx
je 0x2b96
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
jmp 0x2b74
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %ebx
movl %esi, %r14d
testl %esi, %esi
cmovlel %eax, %r14d
movq %rdi, %r15
leaq 0x24552(%rip), %r12     # 0x27110
xorl %r13d, %r13d
cmpq %r14, %r13
je 0x2bf1
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x2be4
movq (%r15,%r13,8), %rax
movzbl (%rax,%rbp), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
incq %rbp
jmp 0x2bc8
pushq $0xa
popq %rdi
callq 0x2040
incq %r13
jmp 0x2bc1
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Algebre.c
// Function: DimensionBorne_tmp
int DimensionBorne_tmp(unsigned char ** __restrict m, const int a, const int b, const int borne) // calcul le rang de la matrice mat de taille a x b, ie la dimension de l'espace engendré par les b vecteurs colonnes.
{
	//PrintMat(m,a,b);
	//getchar();
	int dim = 0;
	const int dim_max = min(a-1,borne);
	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++) // on cherche un pivot sur la colonne
		{
			if (m[new_pivot_l][pivot_c]) // on en a trouvé un
			{
				if (dim!=dim_max)
				{
					if (new_pivot_l!=dim) // on echange les lignes
					{
						unsigned char * __restrict const tmp = m[dim];
						m[dim]=m[new_pivot_l];
						m[new_pivot_l]=tmp;
					}
							
					const unsigned char * const __restrict 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])
						{
							unsigned char * __restrict ligne_need_update = m[ligne];
							const unsigned char coeff = Multiply(Inverse(ligne_pivot[pivot_c]),ligne_need_update[pivot_c]);
							int colonne;
							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++;
					break;
				}
				else return dim+1;
			}
		}
	}
	return dim;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
leal -0x1(%rsi), %eax
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, 0x8(%rsp)
movslq %esi, %r10
xorl %r13d, %r13d
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
leaq 0x143d4(%rip), %rbx     # 0x17010
xorl %eax, %eax
movq %rdi, 0x20(%rsp)
movq %r10, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq %r8, %r13
je 0x2d1e
movslq %eax, %rcx
leaq (%rdi,%rcx,8), %rdx
xorl %esi, %esi
leaq (%rcx,%rsi), %r11
cmpq %r10, %r11
jge 0x2d10
movq (%rdx,%rsi,8), %r9
cmpb $0x0, (%r9,%r13)
jne 0x2c7c
incq %rsi
jmp 0x2c5f
cmpl 0x8(%rsp), %eax
je 0x2d18
movl %eax, 0xc(%rsp)
testl %esi, %esi
je 0x2c9a
movq (%rdi,%rcx,8), %r8
movq %r9, (%rdi,%rcx,8)
movq %r8, (%rdx,%rsi,8)
movq (%rdi,%rcx,8), %r15
leaq 0x1(%r11), %r14
cmpq %r10, %r14
jge 0x2d05
movq 0x8(%rdi,%r11,8), %r12
cmpb $0x0, (%r12,%r13)
movq %r14, %r11
je 0x2c9e
movzbl (%r15,%r13), %edi
callq 0x2433
movzbl (%r12,%r13), %ecx
movzbl %al, %eax
shll $0x8, %eax
addq %rbx, %rax
movzbl (%rcx,%rax), %eax
shll $0x8, %eax
movq %r13, %rcx
leal 0x1(%rcx), %edx
cmpl %ebp, %edx
jge 0x2cf6
movzbl 0x1(%r15,%rcx), %edx
leaq (%rax,%rbx), %rsi
movb (%rdx,%rsi), %dl
xorb %dl, 0x1(%r12,%rcx)
incq %rcx
jmp 0x2cd8
movq %r14, %r11
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %r10
jmp 0x2c9e
movl 0xc(%rsp), %eax
incl %eax
movq 0x10(%rsp), %r8
incq %r13
jmp 0x2c4d
movl 0x8(%rsp), %eax
incl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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 $0x28, %rsp
movl %edx, %ebx
movl %esi, 0x8(%rsp)
movslq %esi, %r10
xorl %r13d, %r13d
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
leaq 0x142b6(%rip), %rbp     # 0x17010
xorl %eax, %eax
movq %rdi, 0x20(%rsp)
movq %r10, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq %r8, %r13
je 0x2e32
movslq %eax, %rcx
leaq (%rdi,%rcx,8), %rdx
xorl %esi, %esi
leaq (%rcx,%rsi), %r11
cmpq %r10, %r11
jge 0x2e2a
movq (%rdx,%rsi,8), %r9
cmpb $0x0, (%r9,%r13)
jne 0x2d9a
incq %rsi
jmp 0x2d7d
movl %eax, 0xc(%rsp)
testl %esi, %esi
je 0x2dae
movq (%rdi,%rcx,8), %r8
movq %r9, (%rdi,%rcx,8)
movq %r8, (%rdx,%rsi,8)
movq (%rdi,%rcx,8), %r15
leaq 0x1(%r11), %r14
cmpq %r10, %r14
jge 0x2e19
movq 0x8(%rdi,%r11,8), %r12
cmpb $0x0, (%r12,%r13)
movq %r14, %r11
je 0x2db2
movzbl (%r15,%r13), %edi
callq 0x2433
movzbl (%r12,%r13), %ecx
movzbl %al, %eax
shll $0x8, %eax
addq %rbp, %rax
movzbl (%rcx,%rax), %eax
shll $0x8, %eax
movq %r13, %rcx
leal 0x1(%rcx), %edx
cmpl %ebx, %edx
jge 0x2e0a
movzbl 0x1(%r15,%rcx), %edx
leaq (%rax,%rbp), %rsi
movb (%rdx,%rsi), %dl
xorb %dl, 0x1(%r12,%rcx)
incq %rcx
jmp 0x2dec
movq %r14, %r11
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %r10
jmp 0x2db2
movl 0xc(%rsp), %eax
incl %eax
cmpl 0x8(%rsp), %eax
movq 0x10(%rsp), %r8
je 0x2e32
incq %r13
jmp 0x2d6b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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 0x2efe
movslq %ebp, %r13
leaq (,%r13,8), %rdi
callq 0x21c0
movq %rax, %r15
movl %ebx, %eax
imull %ebp, %eax
movslq %eax, %rdi
callq 0x21c0
movq %rax, %r12
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
movslq %ebx, %rdx
testl %r13d, %r13d
movl $0x0, %esi
cmovgl %ebp, %esi
movq %r12, %rdi
cmpq %rsi, %rax
je 0x2ecf
movq %rax, %r8
imulq %rdx, %r8
addq %r12, %r8
movq %r8, (%r15,%rax,8)
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x2ec7
movq (%r14,%rax,8), %r9
movb (%r9,%r8), %r9b
movb %r9b, (%rdi,%r8)
incq %r8
jmp 0x2eb1
incq %rax
addq %rdx, %rdi
jmp 0x2e9b
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2d2d
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 0x2d2d
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movl %r8d, 0x8(%rsp)
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, 0x20(%rsp)
movslq %r8d, %rax
movq %rax, 0x18(%rsp)
leaq (,%rax,8), %rdi
callq 0x21c0
movq %rax, 0x10(%rsp)
leal (%r14,%rbp), %eax
movl %eax, 0xc(%rsp)
cltq
movq %rax, 0x30(%rsp)
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %ebx
cmovgl %ebp, %ebx
movslq %ebp, %rax
movq %rax, 0x28(%rsp)
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpl $0x0, 0x18(%rsp)
movl $0x0, %ebp
cmovgl 0x8(%rsp), %ebp
cmpq %rbp, %r15
je 0x3438
movq 0x30(%rsp), %rdi
callq 0x21c0
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x3418
movq (%r13,%r15,8), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x3403
addq 0x28(%rsp), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x3433
movq (%r12,%r15,8), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x341f
incq %r15
jmp 0x33e9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x2f18
movl %eax, %r14d
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x346a
movq (%r15,%rbx,8), %rdi
callq 0x2030
incq %rbx
jmp 0x3457
movq %r15, %rdi
callq 0x2030
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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, %r15d
movl %r8d, %ebp
movq %rcx, 0x18(%rsp)
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movslq %r8d, %r14
leaq (,%r14,8), %rdi
callq 0x21c0
movq %rax, %rbx
cmpl %r15d, %r13d
movl %r15d, 0xc(%rsp)
cmovgl %r13d, %r15d
movslq %r15d, %r12
xorl %r15d, %r15d
testl %r14d, %r14d
movl $0x0, %r14d
cmovgl %ebp, %r14d
cmpq %r15, %r14
je 0x395e
movq %r12, %rdi
callq 0x21c0
movq %rax, (%rbx,%r15,8)
incq %r15
jmp 0x3948
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x3484
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x2f18
movl %eax, %ebp
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x39a4
movq (%rbx,%r15,8), %rdi
callq 0x2030
incq %r15
jmp 0x3991
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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, %r15d
movl %r8d, %ebp
movq %rcx, 0x18(%rsp)
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movslq %r8d, %r14
leaq (,%r14,8), %rdi
callq 0x21c0
movq %rax, %rbx
cmpl %r15d, %r13d
movl %r15d, 0xc(%rsp)
cmovgl %r13d, %r15d
movslq %r15d, %r12
xorl %r15d, %r15d
testl %r14d, %r14d
movl $0x0, %r14d
cmovgl %ebp, %r14d
cmpq %r15, %r14
je 0x3fad
movq %r12, %rdi
callq 0x21c0
movq %rax, (%rbx,%r15,8)
incq %r15
jmp 0x3f97
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x39bd
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x2f18
movl %eax, %ebp
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x3ff3
movq (%rbx,%r15,8), %rdi
callq 0x2030
incq %r15
jmp 0x3fe0
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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
leaq 0x230f6(%rip), %r15     # 0x2711a
leaq 0x230fa(%rip), %r12     # 0x27125
leaq 0x230e4(%rip), %rbp     # 0x27116
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x40a4
testq %r13, %r13
je 0x404c
movq %rbp, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movl (%rax,%r13,4), %eax
movzbl (%rcx,%r13), %esi
testl %eax, %eax
je 0x4095
cmpl $0x1, %esi
je 0x407c
leaq 0x230b2(%rip), %rdi     # 0x2711f
xorl %eax, %eax
callq 0x2110
movq 0x8(%r14), %rax
movl (%rax,%r13,4), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0xbf23
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2110
jmp 0x409f
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r13
jmp 0x4035
testl %eax, %eax
je 0x40bd
cmpl $0x0, 0x18(%r14)
je 0x40bd
leaq 0x23060(%rip), %rdi     # 0x27116
xorl %eax, %eax
callq 0x2110
leaq 0x23067(%rip), %r13     # 0x2712b
pushq $0x29
popq %rbp
leaq 0x23048(%rip), %r12     # 0x27116
xorl %r15d, %r15d
movslq 0x18(%r14), %rax
cmpq %rax, %r15
jge 0x413d
testq %r15, %r15
je 0x40e9
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x28(%r14), %rax
movzbl (%rax,%r15), %esi
cmpl $0x1, %esi
je 0x4105
leaq 0x23021(%rip), %rdi     # 0x2711f
xorl %eax, %eax
callq 0x2110
movq 0x30(%r14), %rax
cmpb $0x0, (%rax,%r15)
movq %r13, %rdi
je 0x411a
leaq 0x2300e(%rip), %rdi     # 0x27128
xorl %eax, %eax
callq 0x2110
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x400c
movl %ebp, %edi
callq 0x2040
incq %r15
jmp 0x40d1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Equation.c
// Function: 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
leaq 0x22fcd(%rip), %r14     # 0x2712e
leaq 0x22fb7(%rip), %r15     # 0x2711f
leaq 0x22fa7(%rip), %r12     # 0x27116
xorl %r13d, %r13d
movslq (%rbx), %rax
cmpq %rax, %r13
jge 0x41b8
testq %r13, %r13
je 0x4189
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x10(%rbx), %rax
movzbl (%rax,%r13), %esi
cmpl $0x1, %esi
je 0x41a1
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
jmp 0x4172
testl %eax, %eax
je 0x41d0
cmpl $0x0, 0x18(%rbx)
je 0x41d0
leaq 0x22f4d(%rip), %rdi     # 0x27116
xorl %eax, %eax
callq 0x2110
leaq 0x22f54(%rip), %r12     # 0x2712b
pushq $0x29
popq %rbp
leaq 0x22f3e(%rip), %r14     # 0x2711f
leaq 0x22f2e(%rip), %r15     # 0x27116
xorl %r13d, %r13d
movslq 0x18(%rbx), %rax
cmpq %rax, %r13
jge 0x4262
testq %r13, %r13
je 0x4203
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x28(%rbx), %rax
movzbl (%rax,%r13), %esi
cmpl $0x1, %esi
je 0x421b
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x30(%rbx), %rax
cmpb $0x0, (%rax,%r13)
movq %r12, %rdi
je 0x4230
leaq 0x22ef8(%rip), %rdi     # 0x27128
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rax
movq (%rax,%r13,8), %rdi
callq 0x414c
movl %ebp, %edi
callq 0x2040
movq 0x28(%rbx), %rax
cmpb $0x1, (%rax,%r13)
je 0x425d
movl %ebp, %edi
callq 0x2040
incq %r13
jmp 0x41eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Equation.c
// Function: 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
pushq $0x38
popq %rdi
callq 0x21c0
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andl $0x0, 0x18(%rax)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4318
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x42c8
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0x4309
xorl %r14d, %r14d
cltq
cmpq %rax, %r14
jge 0x42ee
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x42a5
incq %r14
movl 0x18(%rbx), %eax
jmp 0x42d2
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_O2/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, %rbx
pushq $0x38
popq %rdi
callq 0x21c0
movq %rax, %r14
movslq 0x18(%rbx), %r13
movl %r13d, 0x18(%rax)
testq %r13, %r13
movq %rax, (%rsp)
je 0x43bc
leaq (,%r13,8), %rdi
callq 0x21c0
movq %rax, %r15
movq %rax, 0x20(%r14)
movq %r13, %rdi
callq 0x21c0
movq %rax, %r12
movq %rax, 0x30(%r14)
movq %r13, %rdi
callq 0x21c0
movq %rax, %rbp
movq %rax, 0x28(%r14)
xorl %r14d, %r14d
testl %r13d, %r13d
movq %r13, %rax
movl $0x0, %r13d
cmovgl %eax, %r13d
cmpq %r14, %r13
je 0x43c9
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4319
movq %rax, (%r15,%r14,8)
movq 0x28(%rbx), %rax
movb (%rax,%r14), %al
movb %al, (%rbp,%r14)
movq 0x30(%rbx), %rax
movb (%rax,%r14), %al
movb %al, (%r12,%r14)
incq %r14
jmp 0x4388
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
andq $0x0, 0x30(%r14)
movslq (%rbx), %r12
movq (%rsp), %r14
movl %r12d, (%r14)
testq %r12, %r12
je 0x4427
leaq (,%r12,4), %rdi
callq 0x21c0
movq %rax, %r15
movq %rax, 0x8(%r14)
movq %r12, %rdi
callq 0x21c0
movq %rax, 0x10(%r14)
xorl %ecx, %ecx
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
cmpq %rcx, %rdx
je 0x442f
movq 0x8(%rbx), %rsi
movl (%rsi,%rcx,4), %esi
movl %esi, (%r15,%rcx,4)
movq 0x10(%rbx), %rsi
movb (%rsi,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x4406
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
xorl %ebp, %ebp
cmpl (%rsi), %eax
jne 0x44a5
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %r15d
cmpl 0x18(%rsi), %r15d
jne 0x44a5
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %ebp, %ebp
cmpq %rax, %rcx
je 0x44b6
xorl %edx, %edx
cmpq %rdx, %rax
je 0x44a5
movq 0x8(%r14), %rsi
movl (%rsi,%rcx,4), %edi
movq 0x8(%rbx), %r8
leaq 0x1(%rdx), %rsi
cmpl (%r8,%rdx,4), %edi
movq %rsi, %rdx
jne 0x4474
movq 0x10(%r14), %rdx
movb (%rdx,%rcx), %dl
movq 0x10(%rbx), %rdi
incq %rcx
cmpb -0x1(%rdi,%rsi), %dl
je 0x446d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
xorl %ebp, %ebp
cmpq %r15, %r12
je 0x4516
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x44a5
movq 0x30(%r14), %rax
movb (%rax,%r12), %al
movq 0x30(%rbx), %rcx
cmpb (%rcx,%r13), %al
jne 0x44fa
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rdi
movq 0x20(%rbx), %rax
movq (%rax,%r13,8), %rsi
callq 0x4441
testl %eax, %eax
jne 0x44ff
incq %r13
jmp 0x44ca
movq 0x28(%r14), %rax
movb (%rax,%r12), %al
movq 0x28(%rbx), %rcx
incq %r12
cmpb (%rcx,%r13), %al
je 0x44c2
jmp 0x44a5
pushq $0x1
popq %rbp
jmp 0x44a5
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x38
popq %rdi
callq 0x21c0
movq %rax, %r14
testq %rax, %rax
jne 0x4548
leaq 0x22bf8(%rip), %rdi     # 0x27134
xorl %eax, %eax
callq 0x2110
callq 0x2170
movl $0x1, (%r14)
pushq $0x4
popq %rdi
callq 0x21c0
movq %rax, %r15
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0x4576
leaq 0x22bca(%rip), %rdi     # 0x27134
xorl %eax, %eax
callq 0x2110
callq 0x2170
pushq $0x1
popq %rdi
callq 0x21c0
movq %rax, %r12
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x459d
leaq 0x22ba3(%rip), %rdi     # 0x27134
xorl %eax, %eax
callq 0x2110
callq 0x2170
andl $0x0, 0x18(%r14)
movl %ebx, (%r15)
movb $0x1, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
andq $0x0, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/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:
testl %edi, %edi
je 0x4271
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x38
popq %rdi
callq 0x21c0
movq %rax, %r15
movslq (%rbx), %r12
movl %r12d, (%rax)
movl 0x18(%rbx), %r9d
movl %r9d, 0x18(%rax)
movzbl %bpl, %r14d
testq %r12, %r12
movq %r9, 0x8(%rsp)
jle 0x4665
leaq (,%r12,4), %rdi
callq 0x21c0
movq %rax, %r13
movq %rax, 0x8(%r15)
movq %r12, %rdi
callq 0x21c0
movq 0x8(%rsp), %r9
movq %rax, 0x10(%r15)
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
leaq 0x129d2(%rip), %rdi     # 0x17010
cmpq %rsi, %r12
je 0x466d
movl (%rcx,%rsi,4), %r8d
movl %r8d, (%r13,%rsi,4)
movzbl (%rdx,%rsi), %r8d
shll $0x8, %r8d
addq %rdi, %r8
movb (%r14,%r8), %r8b
movb %r8b, (%rax,%rsi)
incq %rsi
jmp 0x463e
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
testl %r9d, %r9d
movq %r15, 0x10(%rsp)
jle 0x46f5
leaq (,%r9,8), %rdi
movq %r9, %rbp
callq 0x21c0
movq %rax, %r12
movq %rax, 0x20(%r15)
movq %rbp, %rdi
callq 0x21c0
movq %rax, %r13
movq %rax, 0x30(%r15)
movq %rbp, %rdi
callq 0x21c0
movq %rax, %rbp
movq %rax, 0x28(%r15)
xorl %r15d, %r15d
cmpq %r15, 0x8(%rsp)
je 0x4702
movq 0x30(%rbx), %rax
movb (%rax,%r15), %al
movb %al, (%r13,%r15)
movq 0x28(%rbx), %rax
movzbl (%rax,%r15), %eax
shll $0x8, %eax
addq 0x2b90a(%rip), %rax     # 0x2ffe0
movb (%r14,%rax), %al
movb %al, (%rbp,%r15)
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x4319
movq %rax, (%r12,%r15,8)
incq %r15
jmp 0x46af
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
andq $0x0, 0x30(%r15)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Equation.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
pushq $0x1
popq %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x4d54
movq 0x8(%r14), %rsi
leaq 0x1(%rdx), %rdi
cmpl %ebx, (%rsi,%rdx,4)
movq %rdi, %rdx
jne 0x4d3c
movl %ecx, %r15d
movl 0x18(%r14), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x4d7e
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %rdi
movl %ebx, %esi
callq 0x4d1e
addl %eax, %r15d
incq %r13
jmp 0x4d62
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq