LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/util.c
// Function: ifstat2
static bool
ifstat2(const char *file1, const char *file2, int act)
{
	struct stat sb1, sb2;
	bool rs;

	if (file1 == NULL || *file1 == EOS)
		return false;
	if (file2 == NULL || *file2 == EOS)
		return false;

	if (stat(file1, &sb1) < 0)
		return false;
	if (stat(file2, &sb2) < 0)
		return false;

	if (act == F_OT)
		rs = sb1.st_mtime < sb2.st_mtime;
	else if (act == F_NT)
		rs = sb1.st_mtime > sb2.st_mtime;
	else if (act == F_EF)
		rs = sb1.st_dev == sb2.st_dev && sb1.st_ino == sb2.st_ino;
	else
		rs = false;

	return rs;
}

// Assembly:
testq %rdi, %rdi
je 0x7ae2
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r14
xorl %eax, %eax
testq %rsi, %rsi
je 0x7ae7
cmpb $0x0, (%rdi)
je 0x7ae7
cmpb $0x0, (%r14)
je 0x7ae5
movl %edx, %ebx
leaq 0x98(%rsp), %rsi
callq 0x2270
testl %eax, %eax
js 0x7ae5
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2270
testl %eax, %eax
js 0x7ae5
cmpl $0x3, %ebx
je 0x7af2
cmpl $0x2, %ebx
jne 0x7b04
movq 0xf0(%rsp), %rax
cmpq 0x60(%rsp), %rax
setl %al
jmp 0x7ae7
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movq 0xf0(%rsp), %rax
cmpq 0x60(%rsp), %rax
setg %al
jmp 0x7ae7
movq 0x98(%rsp), %rax
xorq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
xorq 0xa0(%rsp), %rcx
orq %rax, %rcx
sete %al
jmp 0x7ae7
nop
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: smalloc
void* smalloc(size_t size, const char* fmt, ...)
{
    if (size <= 0)
        return NULL;

    void*   buf = NULL;

    va_list args;

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

        return NULL;
    }
    memset(buf, '\0', size);

    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1235
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 %rdi, %rdi
je 0x125e
movq %rsi, %r14
movq %rdi, %rsi
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
testq %rax, %rax
jne 0x1260
testq %r14, %r14
jne 0x126e
callq 0x10b0
jmp 0x1260
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x2d5e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x1260
// File: /workspace/github_c_makefile_star2_O3/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 0x1300
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 0x131b
movq %rdx, %r15
movq %rbx, %rdi
callq 0x1070
movq %rax, %r14
testq %rax, %rax
je 0x132b
movq %r14, %rbx
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %r15, %r15
jne 0x1337
callq 0x10e6
jmp 0x136e
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 0x2c95(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq %r15, %rsi
callq 0x1080
testq %rbx, %rbx
je 0x1318
movq %rbx, %rdi
callq 0x1030
jmp 0x1318
// File: /workspace/github_c_makefile_star2_O3/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
testl %esi, %esi
jle 0x13cd
movl %esi, %r14d
decq %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x13a8
callq 0x1030
movq $0x0, (%rbx,%r15,8)
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x13be
callq 0x1030
movq $0x0, (%rbx,%r14,8)
incq %r15
leaq -0x1(%r14), %rax
cmpq %r14, %r15
movq %rax, %r14
jl 0x1392
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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 0x2506
movl %eax, %edi
movl %edx, %r9d
movl %eax, %r8d
movl %edi, %r10d
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
cmpl $0x1, %edi
movl %r8d, %edi
ja 0x24d2
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_O3/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
testl %esi, %esi
setle %al
testl %ecx, %ecx
setle %r9b
xorl %r10d, %r10d
orb %al, %r9b
movl $0x0, %r9d
movl $0x0, %eax
jne 0x281a
xorl %eax, %eax
xorl %r9d, %r9d
xorl %r10d, %r10d
movslq %r10d, %r11
movl (%rdi,%r11,4), %r11d
movslq %r9d, %rbx
movl (%rdx,%rbx,4), %ebx
cmpl %ebx, %r11d
jge 0x27f8
incl %r10d
jmp 0x2809
sete %r11b
movzbl %r11b, %r11d
addl %r11d, %r10d
incl %r9d
movl %ebx, %r11d
movl %r11d, (%r8,%rax,4)
incq %rax
cmpl %esi, %r10d
jge 0x281a
cmpl %ecx, %r9d
jl 0x27e1
cmpl %esi, %r10d
jge 0x2846
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 0x2834
addl %edi, %eax
cmpl %ecx, %r9d
jge 0x2872
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 0x2860
addl %edx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
je 0x2891
subl %esi, %ecx
movl %esi, %eax
xorl %esi, %esi
movl (%rdx,%rsi,4), %r8d
cmpl %r8d, (%rdi,%rsi,4)
jl 0x2899
jg 0x289f
incq %rsi
cmpl %esi, %eax
jne 0x287e
xorl %eax, %eax
testl %ecx, %ecx
setne %al
retq
movl $0x1, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2978
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 0x2960
incl %edx
jmp 0x296f
jne 0x296d
incl %edx
movslq %r13d, %rdi
incl %r13d
movl %esi, (%rax,%rdi,4)
incl %ecx
cmpl %r15d, %edx
jge 0x2978
cmpl %ebp, %ecx
jl 0x294c
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_O3/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 0x2a0d
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 0x29fa
incl %ebx
movslq %eax, %rsi
incl %eax
movl %edx, (%r14,%rsi,4)
jmp 0x2a04
sete %dl
movzbl %dl, %edx
addl %edx, %ebx
incl %ecx
cmpl %ebp, %ebx
jge 0x2a0d
cmpl %r12d, %ecx
jl 0x29dc
cmpl %ebp, %ebx
jge 0x2ad8
movslq %eax, %r12
leaq (%r14,%r12,4), %rdi
movslq %ebx, %r13
leaq (%r15,%r13,4), %rsi
notl %ebx
addl %ebp, %ebx
leaq 0x4(,%rbx,4), %rdx
callq 0x21b0
movslq %ebp, %rcx
subq %r13, %rcx
leaq 0x1(%rcx), %rax
andq $-0x2, %rax
decq %rcx
movq %r12, %xmm0
movq %rcx, %xmm1
pshufd $0x44, %xmm1, %xmm2     # xmm2 = xmm1[0,1,0,1]
movl $0x2, %ecx
pcmpeqd %xmm3, %xmm3
movdqa %xmm0, %xmm1
psubq %xmm3, %xmm0
leaq (%rax,%rcx), %rdx
addq $-0x2, %rdx
addq $-0x2, %rcx
cmpq $0x2, %rdx
jne 0x2a5d
negq %rcx
movq %rcx, %xmm3
pshufd $0x44, %xmm3, %xmm3     # xmm3 = xmm3[0,1,0,1]
por 0x26684(%rip), %xmm3    # 0x29110
movdqa 0x2668c(%rip), %xmm4    # 0x29120
pxor %xmm4, %xmm2
pxor %xmm4, %xmm3
movdqa %xmm3, %xmm4
pcmpgtd %xmm2, %xmm4
pshufd $0xa0, %xmm4, %xmm5     # xmm5 = xmm4[0,0,2,2]
pcmpeqd %xmm2, %xmm3
pshufd $0xf5, %xmm3, %xmm2     # xmm2 = xmm3[1,1,3,3]
pand %xmm5, %xmm2
pshufd $0xf5, %xmm4, %xmm3     # xmm3 = xmm4[1,1,3,3]
por %xmm2, %xmm3
pand %xmm3, %xmm1
pandn %xmm0, %xmm3
por %xmm1, %xmm3
pshufd $0xee, %xmm3, %xmm0     # xmm0 = xmm3[2,3,2,3]
paddq %xmm3, %xmm0
movd %xmm0, %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_O3/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 0x2b58
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2b2c
movl %r15d, %esi
subl %ebp, %esi
movslq %ebp, %r12
cmpl $0x3, %esi
jl 0x2b71
leaq (%rbx,%r12,4), %rdi
movq %r14, %rdx
callq 0x2b2c
cmpl $0x2, %r15d
jl 0x2bc4
movl %ebp, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2b7b
cmpl $0x2, %r15d
jl 0x2bc4
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 0x2baf
jle 0x2baf
incl %edx
movl %edi, %esi
jmp 0x2bb1
incl %eax
movl %esi, (%rbx,%rcx,4)
incq %rcx
cmpl %ebp, %eax
jge 0x2bc0
cmpl %r15d, %edx
jl 0x2b96
movl %ecx, %ecx
jmp 0x2bc8
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %ebp, %eax
jge 0x2bea
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 0x2bdc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2caa
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x2c75
movl %r15d, %edx
subl %ebp, %edx
movslq %ebp, %r13
cmpl $0x3, %edx
jl 0x2cc6
leaq (%rbx,%r13,4), %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x2c75
cmpl $0x2, %r15d
jl 0x2d20
movl %ebp, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2cd0
cmpl $0x2, %r15d
jl 0x2d20
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 0x2d0b
jle 0x2d0b
incl %edx
movl %edi, %esi
jmp 0x2d0d
incl %eax
movl %esi, (%rbx,%rcx,4)
incq %rcx
cmpl %ebp, %eax
jge 0x2d1c
cmpl %r15d, %edx
jl 0x2ceb
movl %ecx, %ecx
jmp 0x2d24
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %ebp, %eax
jge 0x2d46
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 0x2d38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cbouilla[P]AES-attacks-finder/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 0x2d9e
movl $0x1, %eax
testl %esi, %esi
jle 0x2e02
movl %esi, %ecx
xorl %esi, %esi
movl (%rdi,%rsi,4), %r8d
cmpl (%rdx,%rsi,4), %r8d
jne 0x2e00
incq %rsi
cmpq %rsi, %rcx
jne 0x2d8a
jmp 0x2e02
movl %ecx, %r10d
movl %esi, %eax
sarl %eax
movslq %eax, %r11
movl (%rdi,%r11,4), %r8d
xorl %eax, %eax
xorl %r9d, %r9d
movl %ecx, %r14d
cmpl %r14d, %r9d
jge 0x2e02
leal (%r14,%r9), %ecx
shrl %ecx
leal 0x1(%rcx), %ebx
movl %ecx, %ebp
cmpl %r8d, (%rdx,%rcx,4)
jg 0x2dd0
movl %ebx, %r9d
movl %r14d, %ebp
movl %ebp, %r14d
jne 0x2db4
leaq (%rdi,%r11,4), %r8
addq $0x4, %r8
movl %r11d, %r9d
notl %r9d
addl %esi, %r9d
movl %ebx, %eax
leaq (%rdx,%rax,4), %rax
subl %ebx, %r10d
movl %r11d, %esi
pushq %r10
pushq %rax
callq 0x2e07
addq $0x10, %rsp
jmp 0x2e02
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e44
testl %ebx, %ebx
jle 0x2e58
cmpl %ecx, %esi
setg %al
cmpl %ebp, %ebx
setg %r8b
xorl %r12d, %r12d
orb %al, %r8b
jne 0x2e74
callq 0x2d75
testl %eax, %eax
jne 0x2e4c
jmp 0x2e74
testl %ebx, %ebx
jle 0x2e6e
cmpl %ebp, %ebx
jg 0x2e5c
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movl %ebp, %ecx
jmp 0x2e61
cmpl %ecx, %esi
jle 0x2e61
xorl %r12d, %r12d
jmp 0x2e74
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d75
movl $0x1, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ede
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %r9d, %eax
movl %r8d, %r10d
movl (%rdx,%r10,4), %r10d
cmpl %r10d, (%rdi,%rax,4)
je 0x2edf
setge %r10b
setl %al
movzbl %al, %eax
addl %eax, %r9d
xorl %eax, %eax
cmpl %esi, %r9d
jge 0x2ede
movzbl %r10b, %r10d
addl %r10d, %r8d
cmpl %ecx, %r8d
jl 0x2eae
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3160
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_O3/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 0x31a5
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 0x3185
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3202
movq %rdi, %r14
movl %esi, %r12d
movl 0x4(%rsp), %r13d
leaq 0x25fa5(%rip), %r15     # 0x29170
xorl %ebp, %ebp
cmpl $0x0, 0x4(%rsp)
jle 0x31f0
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 0x31d6
movl $0xa, %edi
callq 0x2040
incq %rbp
cmpq %r12, %rbp
jne 0x31cd
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_O3/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 0x34a2
movslq %esi, %rax
movq %rax, 0x30(%rsp)
movl %edx, %r13d
xorl %ebp, %ebp
movl $0x1, %r10d
leaq 0x15c67(%rip), %r15     # 0x19010
xorl %ecx, %ecx
movl %esi, 0x14(%rsp)
movl %esi, %edi
subl %ecx, %edi
jle 0x33d9
movslq %ecx, %rax
leal 0x1(%rcx), %r11d
movq 0x8(%rsp), %rdx
leaq (%rdx,%rax,8), %r9
xorl %edx, %edx
movq (%r9,%rdx,8), %r8
cmpb $0x0, (%r8,%rbp)
jne 0x33e0
incq %rdx
cmpl %edx, %edi
jne 0x33c7
movl %ecx, %eax
jmp 0x348f
movq %r10, 0x20(%rsp)
testl %edx, %edx
je 0x33fa
movq 0x8(%rsp), %rdi
movq (%rdi,%rax,8), %rcx
movq %r8, (%rdi,%rax,8)
movq %rcx, (%r9,%rdx,8)
movq %r11, 0x18(%rsp)
leal (%r11,%rdx), %ecx
cmpl %esi, %ecx
jge 0x347d
movl 0x18(%rsp), %ecx
addq %rdx, %rcx
movq 0x8(%rsp), %rdx
movq (%rdx,%rax,8), %r12
leaq 0x1(%rbp), %rax
movq %rax, 0x28(%rsp)
movslq %ecx, %r14
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rbx
cmpb $0x0, (%rbx,%rbp)
je 0x3473
movzbl (%r12,%rbp), %edi
callq 0x2534
cmpq %r13, 0x28(%rsp)
jae 0x3473
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 0x345c
incq %r14
cmpq 0x30(%rsp), %r14
jl 0x3423
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rax
cmpl %esi, %eax
movq 0x20(%rsp), %r10
je 0x34a4
incq %rbp
incq %r10
movl %eax, %ecx
cmpq %r13, %rbp
jne 0x33af
jmp 0x34a4
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cbouilla[P]AES-attacks-finder/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 0x3564
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 0x3535
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 0x352a
movq (%r14,%rsi,8), %r8
xorl %r9d, %r9d
movb (%r8,%r9), %r10b
movb %r10b, (%rdi,%r9)
incq %r9
cmpq %r9, %rdx
jne 0x351a
incq %rsi
addq %rax, %rdi
cmpq %rcx, %rsi
jne 0x3501
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3374
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 0x3374
// File: /workspace/github_c_makefile_star2_O3/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, %r13d
movl %r8d, %r15d
movq %rcx, 0x20(%rsp)
movl %edx, %ebp
movq %rsi, 0x18(%rsp)
movq %rdi, %r12
movslq %r8d, %r14
leaq (,%r14,8), %rdi
callq 0x21d0
movq %rax, %rbx
leal (%r13,%rbp), %ecx
testl %r14d, %r14d
jle 0x3b62
movq %r12, 0x8(%rsp)
movl %ecx, (%rsp)
movslq %ecx, %rax
movq %rax, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
movslq %ebp, %rax
movl %r15d, 0x4(%rsp)
movl %r15d, %r12d
movq %rax, 0x10(%rsp)
movl %eax, %r15d
movq %r13, %rbp
movl %r13d, %r14d
xorl %r13d, %r13d
movq 0x28(%rsp), %rdi
callq 0x21d0
movq %rax, (%rbx,%r13,8)
cmpl $0x0, 0x30(%rsp)
jle 0x3b01
movq 0x18(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r15
jne 0x3af1
testl %ebp, %ebp
jle 0x3b25
movq 0x20(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
addq 0x10(%rsp), %rax
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r14
jne 0x3b15
incq %r13
cmpq %r12, %r13
jne 0x3ad1
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl 0x4(%rsp), %r14d
movl %r14d, %edx
movl (%rsp), %ecx
callq 0x357e
movl %eax, %ebp
testl %r14d, %r14d
jle 0x3b72
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x2030
incq %r14
cmpq %r14, %r12
jne 0x3b4f
jmp 0x3b72
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x357e
movl %eax, %ebp
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_O3/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 0x40c2
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 0x40ae
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x3b8b
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x357e
movl %eax, %r15d
testl %ebp, %ebp
jle 0x410b
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x2030
incq %r12
cmpq %r12, %r14
jne 0x40fa
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_O3/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 0x47ba
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 0x47a6
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x4125
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x357e
movl %eax, %r15d
testl %ebp, %ebp
jle 0x4803
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x2030
incq %r12
cmpq %r12, %r14
jne 0x47f2
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_O3/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 0x48c0
leaq 0x24938(%rip), %r15     # 0x2917a
leaq 0x2493c(%rip), %r12     # 0x29185
leaq 0x24926(%rip), %rbp     # 0x29176
xorl %r13d, %r13d
testq %r13, %r13
je 0x4862
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 0x48ab
cmpl $0x1, %esi
je 0x4892
leaq 0x248fc(%rip), %rdi     # 0x2917f
xorl %eax, %eax
callq 0x2110
movq 0x8(%r14), %rax
movl (%rax,%r13,4), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0xd2a9
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2110
jmp 0x48b5
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x4853
testl %eax, %eax
je 0x48d9
cmpl $0x0, 0x18(%r14)
je 0x48d9
leaq 0x248a4(%rip), %rdi     # 0x29176
xorl %eax, %eax
callq 0x2110
cmpl $0x0, 0x18(%r14)
jle 0x495e
leaq 0x248a4(%rip), %r13     # 0x2918b
leaq 0x24891(%rip), %r15     # 0x2917f
leaq 0x24881(%rip), %r12     # 0x29176
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x4906
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x28(%r14), %rax
movzbl (%rax,%rbp), %esi
cmpl $0x1, %esi
je 0x491d
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x30(%r14), %rax
cmpb $0x0, (%rax,%rbp)
movq %r13, %rdi
je 0x4931
leaq 0x24857(%rip), %rdi     # 0x29188
xorl %eax, %eax
callq 0x2110
movq 0x20(%r14), %rax
movq (%rax,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x4820
movl $0x29, %edi
callq 0x2040
incq %rbp
movslq 0x18(%r14), %rax
cmpq %rax, %rbp
jl 0x48f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cbouilla[P]AES-attacks-finder/Equation.c
// Function: 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 0x49dd
leaq 0x24806(%rip), %r14     # 0x2918e
leaq 0x247f0(%rip), %r15     # 0x2917f
leaq 0x247e0(%rip), %r12     # 0x29176
xorl %r13d, %r13d
testq %r13, %r13
je 0x49a8
movq %r12, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x10(%rbx), %rax
movzbl (%rax,%r13), %esi
cmpl $0x1, %esi
je 0x49c0
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 0x4999
testl %eax, %eax
je 0x49f5
cmpl $0x0, 0x18(%rbx)
je 0x49f5
leaq 0x24788(%rip), %rdi     # 0x29176
xorl %eax, %eax
callq 0x2110
cmpl $0x0, 0x18(%rbx)
jle 0x4a91
leaq 0x24785(%rip), %r12     # 0x2918b
leaq 0x2477b(%rip), %r13     # 0x29188
leaq 0x2476b(%rip), %r14     # 0x2917f
leaq 0x2475b(%rip), %r15     # 0x29176
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x4a2c
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x28(%rbx), %rax
movzbl (%rax,%rbp), %esi
cmpl $0x1, %esi
je 0x4a43
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x30(%rbx), %rax
cmpb $0x0, (%rax,%rbp)
movq %r12, %rdi
je 0x4a53
movq %r13, %rdi
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rax
movq (%rax,%rbp,8), %rdi
callq 0x496d
movl $0x29, %edi
callq 0x2040
movq 0x28(%rbx), %rax
cmpb $0x1, (%rax,%rbp)
je 0x4a85
movl $0x29, %edi
callq 0x2040
incq %rbp
movslq 0x18(%rbx), %rax
cmpq %rax, %rbp
jl 0x4a1d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cbouilla[P]AES-attacks-finder/Equation.c
// Function: 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 0x4b4a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x4afc
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
cmpl $0x0, 0x18(%rbx)
je 0x4b3b
jle 0x4b20
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4ad9
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x4b07
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_O3/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 0x4be2
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 0x4bf1
movq %rax, %rbp
xorl %ebx, %ebx
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rdi
callq 0x4b4b
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 0x4bb0
jmp 0x4bf1
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq $0x0, 0x30(%rbx)
movslq (%r14), %r15
movq (%rsp), %rbx
movl %r15d, (%rbx)
testq %r15, %r15
je 0x4c48
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 0x4c4f
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 0x4c2f
jmp 0x4c4f
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_O3/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), %r10d
xorl %eax, %eax
cmpl (%rsi), %r10d
jne 0x4d62
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbp
movl 0x18(%rdi), %r13d
cmpl 0x18(%rsi), %r13d
jne 0x4d54
testl %r10d, %r10d
jle 0x4cd4
movq 0x8(%rbp), %rcx
movq 0x8(%rsi), %rdx
xorl %eax, %eax
movl (%rcx,%rax,4), %r8d
xorl %edi, %edi
cmpl (%rdx,%rdi,4), %r8d
je 0x4cb6
incq %rdi
cmpq %rdi, %r10
jne 0x4ca3
jmp 0x4d52
movq 0x10(%rbp), %r8
movb (%r8,%rax), %r8b
movq 0x10(%rsi), %r9
cmpb (%r9,%rdi), %r8b
jne 0x4d52
incq %rax
cmpq %r10, %rax
jne 0x4c9d
movl $0x1, %eax
testl %r13d, %r13d
jle 0x4d54
movq 0x30(%rbp), %rax
movq 0x30(%rsi), %rbx
xorl %r15d, %r15d
movq %rax, 0x10(%rsp)
movb (%rax,%r15), %al
xorl %r12d, %r12d
movb %al, 0xf(%rsp)
cmpb (%rbx,%r12), %al
jne 0x4d22
movq 0x20(%rbp), %rax
movq (%rax,%r15,8), %rdi
movq 0x20(%rsi), %rax
movq %rsi, %r14
movq (%rax,%r12,8), %rsi
callq 0x4c61
movq %r14, %rsi
testl %eax, %eax
movb 0xf(%rsp), %al
jne 0x4d2c
incq %r12
cmpq %r12, %r13
jne 0x4cf9
jmp 0x4d52
movq 0x28(%rbp), %rax
movb (%rax,%r15), %al
movq 0x28(%rsi), %rcx
cmpb (%rcx,%r12), %al
jne 0x4d52
incq %r15
cmpq %r13, %r15
movq 0x10(%rsp), %rax
jne 0x4cee
movl $0x1, %eax
jmp 0x4d54
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_O3/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 0x4d91
leaq 0x2440f(%rip), %rdi     # 0x29194
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 0x4dc0
leaq 0x243e0(%rip), %rdi     # 0x29194
xorl %eax, %eax
callq 0x2110
callq 0x2180
movl $0x1, %edi
callq 0x21d0
movq %rax, %r15
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x4de9
leaq 0x243b7(%rip), %rdi     # 0x29194
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_O3/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 0x4eb2
movslq (%r14), %r12
movl %r12d, (%r15)
movl 0x18(%r14), %r9d
movl %r9d, 0x18(%r15)
movzbl %bpl, %ebx
testq %r12, %r12
jle 0x4ec8
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 0x14185(%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 0x4e8b
jmp 0x4ed0
xorl %eax, %eax
movl %eax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movl %eax, 0x18(%r15)
jmp 0x4f61
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
testl %r9d, %r9d
jle 0x4f5e
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 0x2d0aa(%rip), %rax     # 0x31fe0
movb (%rbx,%rax), %al
movb %al, (%rbp,%r15)
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x4b4b
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r12
jne 0x4f16
jmp 0x4f6e
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_O3/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 0x579e
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpl %ebx, (%rcx,%rdx,4)
je 0x57a2
incq %rdx
cmpq %rdx, %rax
jne 0x5791
xorl %ebp, %ebp
jmp 0x57a7
movl $0x1, %ebp
movslq 0x18(%rdi), %r14
testq %r14, %r14
jle 0x57cc
movq 0x20(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movl %ebx, %esi
callq 0x5779
addl %eax, %ebp
incq %r12
cmpq %r12, %r14
jne 0x57b7
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq