LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x55b8
cmpl $0x0, -0x14(%rbp)
je 0x551a
leaq 0x2fc03(%rip), %rdi     # 0x35116
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x554c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2fbd7(%rip), %rdi     # 0x3511a
movb $0x0, %al
callq 0x2100
jmp 0x55a8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x557f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2fba7(%rip), %rdi     # 0x3511f
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x12fc0
movq %rax, %rsi
leaq 0x2fb84(%rip), %rdi     # 0x35125
movb $0x0, %al
callq 0x2100
jmp 0x55aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54f7
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x55d9
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x55d9
leaq 0x2fb44(%rip), %rdi     # 0x35116
movb $0x0, %al
callq 0x2100
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x569c
cmpl $0x0, -0x14(%rbp)
je 0x5604
leaq 0x2fb19(%rip), %rdi     # 0x35116
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x5637
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2faef(%rip), %rdi     # 0x3511f
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x5659
leaq 0x2fad8(%rip), %rdi     # 0x35128
movb $0x0, %al
callq 0x2100
jmp 0x5667
leaq 0x2facb(%rip), %rdi     # 0x3512b
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x54e0
leaq 0x30dc2(%rip), %rdi     # 0x36449
movb $0x0, %al
callq 0x2100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x573d
cmpl $0x0, -0xc(%rbp)
je 0x56e2
leaq 0x2fa3b(%rip), %rdi     # 0x35116
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x5715
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2fa11(%rip), %rdi     # 0x3511f
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x2fa03(%rip), %rdi     # 0x3512e
movb $0x0, %al
callq 0x2100
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x56c3
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x575e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x575e
leaq 0x2f9bf(%rip), %rdi     # 0x35116
movb $0x0, %al
callq 0x2100
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x5842
cmpl $0x0, -0xc(%rbp)
je 0x5789
leaq 0x2f994(%rip), %rdi     # 0x35116
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x57bc
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2f96a(%rip), %rdi     # 0x3511f
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x57de
leaq 0x2f953(%rip), %rdi     # 0x35128
movb $0x0, %al
callq 0x2100
jmp 0x57ec
leaq 0x2f946(%rip), %rdi     # 0x3512b
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x56b0
leaq 0x30c41(%rip), %rdi     # 0x36449
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x5832
leaq 0x30c1e(%rip), %rdi     # 0x36449
movb $0x0, %al
callq 0x2100
jmp 0x5834
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5765
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x21c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x59af
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x593a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x599e
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x5977
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5900
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x594b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x38, %edi
callq 0x21c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5dd3
leaq 0x2f36d(%rip), %rdi     # 0x35134
movb $0x0, %al
callq 0x2100
callq 0x2170
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x4, %edi
callq 0x21c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5e10
leaq 0x2f330(%rip), %rdi     # 0x35134
movb $0x0, %al
callq 0x2100
callq 0x2170
movl $0x1, %edi
callq 0x21c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5e43
leaq 0x2f2fd(%rip), %rdi     # 0x35134
movb $0x0, %al
callq 0x2100
callq 0x2170
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6c94
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x6c87
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c94
jmp 0x6c89
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6c5d
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x6cd0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
callq 0x6c40
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6c9b
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Equation.c
// Function: appliqueS
Equation appliqueS(Equation a, unsigned char m)
{	
	Equation p=malloc(sizeof(EQUATION));
	p->nV=0;
	p->var=NULL;
	p->coefV=NULL;
	p->nS=1;
	p->S=malloc(sizeof(Equation));
	p->coefS=malloc(sizeof(unsigned char));
	p->sbox=malloc(sizeof(unsigned char));
	p->S[0]=copyEq(a);
	p->coefS[0]=0x01;
	p->sbox[0]=m;
	Equation pp=reduitEq(p);
	freeEq(p);
	return pp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x38, %edi
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
movl $0x8, %edi
callq 0x21c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %edi
callq 0x21c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, %edi
callq 0x21c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x59c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movb $0x1, (%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rdi
callq 0x6100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5900
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Equation.c
// Function: RemplaceLinearise
void RemplaceLinearise(Equation E, Equation a, int v)
{
	if (EgaleEq(E,a))
	{
		printf("C'est bizarre!!");
		getchar();
	}
	int i;
	for (i = 0; i < E->nS; i++)
	{
		if (EgaleEq(a,E->S[i]))
		{
			freeEq(E->S[i]);
			E->S[i]=varEq(v);
		}
		else RemplaceLinearise(E->S[i],a,v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bc0
cmpl $0x0, %eax
je 0x7528
leaq 0x2dc20(%rip), %rdi     # 0x3513c
movb $0x0, %al
callq 0x2100
callq 0x2170
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x75b7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5bc0
cmpl $0x0, %eax
je 0x758b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5900
movl -0x14(%rbp), %edi
callq 0x5da0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x75a7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x74f0
jmp 0x75a9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x752f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Equation.c
// Function: SupprS
Equation SupprS(Equation E)
{
	int i;
	for (i = 0; i < E->nS; i++)
	{
		if (E->sbox[i]==1)
		{
			Equation tmp=copyEq(E->S[i]);
			Equation tmp1=appliqueS(tmp,1);
			Equation tmp2=mulEq(E->coefS[i],tmp1);
			freeEq(tmp1);
			tmp1=addEq(E,tmp2);
			freeEq(tmp2);
			tmp2=mulEq(Inverse(E->coefS[i]),tmp1);
			freeEq(tmp1);
			tmp1=appliqueS(tmp2,0);
			freeEq(tmp2);
			tmp2=addEq(tmp,tmp1);
			freeEq(tmp);
			freeEq(tmp1);
			int j;
			for (j = i+1; j < E->nS; j++)
			{
				if (E->sbox[j]==1)
				{
					printf("Il reste S^-1");
					getchar();
				}
			}
			
			return tmp2;
		}
	}
	return copyEq(E);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x7736
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x7726
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x59c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x6ce0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x28(%rbp), %rsi
movzbl %al, %edi
callq 0x5ea0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6900
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5900
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x24c0
movq -0x28(%rbp), %rsi
movzbl %al, %edi
callq 0x5ea0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x6ce0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5900
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6900
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5900
movq -0x28(%rbp), %rdi
callq 0x5900
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x771c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x770f
leaq 0x2da49(%rip), %rdi     # 0x3514c
movb $0x0, %al
callq 0x2100
callq 0x2170
jmp 0x7711
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x76db
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7743
jmp 0x7728
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x75d3
movq -0x10(%rbp), %rdi
callq 0x59c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Equation.c
// Function: LineariseTotal
Equation * LineariseTotal(Equation *E, int taille, int *t) /*Bug -> incomplete*/
{
	Equation *Eq,tmp,*Eq2;
	int i,N;
	Eq=Linearise(E,taille,&N);
	for (i = 0; i < N; i++)
	{
		tmp=SupprS(Eq[i]);
		freeEq(Eq[i]);
		Eq[i]=tmp;
	}
	Eq2=Linearise(Eq,N,t);
	for (i = 0; i < N; i++) freeEq(Eq[i]);
	free(Eq);
	return Eq2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x7750
movq %rax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x7ad7
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x75c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5900
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7a8e
movq -0x20(%rbp), %rdi
movl -0x38(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x7750
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x7b16
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5900
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7af2
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Equation.c
// Function: CoupeEq
Equation CoupeEq(Equation a, int *X, int N)
{
	int i,p,v;
	Equation tmp1,tmp2,tmp3;
	tmp1=NulEq();
	for (i = 0; i < a->nV; i++)
	{
		v=a->var[i];
		p=SearchElement(v,X,N);
		if (p!=-1)
		{
			tmp2=varEq(v);
			tmp3=mulEq(a->coefV[i],tmp2);
			freeEq(tmp2);
			tmp2=addEq(tmp3,tmp1);
			freeEq(tmp1);
			freeEq(tmp3);
			tmp1=tmp2;
		}
	}
	for (i = 0; i < a->nS; i++)
	{
		v=a->S[i]->var[0];
		p=SearchElement(v,X,N);
		if (p!=-1)
		{
			tmp2=varEq(v);
			tmp3=appliqueS(tmp2,a->sbox[i]);
			freeEq(tmp2);
			tmp2=mulEq(a->coefS[i],tmp3);
			freeEq(tmp3);
			tmp3=addEq(tmp2,tmp1);
			freeEq(tmp1);
			freeEq(tmp2);
			tmp1=tmp3;
		}
	}
	return tmp1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x5850
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x80db
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2b60
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x80cb
movl -0x20(%rbp), %edi
callq 0x5da0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x30(%rbp), %rsi
movzbl %al, %edi
callq 0x5ea0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6900
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x80cd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8033
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x81bc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2b60
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x81ac
movl -0x20(%rbp), %edi
callq 0x5da0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x6ce0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5900
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x38(%rbp), %rsi
movzbl %al, %edi
callq 0x5ea0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6900
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x81ae
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x80e2
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/EquationAES.c
// Function: MakeAK
int MakeAK(Equation *Eq, int key, int state1, int state2)
{
	int i,j,pos;
	Equation tmp,tmp1,tmp2;
	pos=0;
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			tmp=varEq(16*key+4*i+j);
			tmp1=varEq(16*state1+4*i+j);
			tmp2=addEq(tmp,tmp1);
			freeEq(tmp);
			freeEq(tmp1);
			tmp=varEq(16*state2+4*i+j);
			Eq[pos++]=addEq(tmp,tmp2);
			freeEq(tmp);
			freeEq(tmp2);
		}
	}
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x85d5
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x85c5
movl -0xc(%rbp), %edi
shll $0x4, %edi
movl -0x18(%rbp), %eax
shll $0x2, %eax
addl %eax, %edi
addl -0x1c(%rbp), %edi
callq 0x5da0
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
shll $0x4, %edi
movl -0x18(%rbp), %eax
shll $0x2, %eax
addl %eax, %edi
addl -0x1c(%rbp), %edi
callq 0x5da0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6900
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rdi
callq 0x5900
movl -0x14(%rbp), %edi
shll $0x4, %edi
movl -0x18(%rbp), %eax
shll $0x2, %eax
addl %eax, %edi
addl -0x1c(%rbp), %edi
callq 0x5da0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6900
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rdi
callq 0x5900
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8504
jmp 0x85c7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x84f3
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/EquationAES.c
// Function: MakeSS
int MakeSS(Equation *Eq, int key, int state1, int state2)
{
	int i,j,pos;
	Equation tmp,tmp1,tmp2;
	pos=0;
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			tmp=varEq(16*state2+4*i+j);
			tmp1=appliqueS(tmp,1);
			freeEq(tmp);
			tmp=varEq(16*state1+4*((i+j)%4)+j);
			tmp2=addEq(tmp,tmp1);
			freeEq(tmp);
			freeEq(tmp1);
			tmp=varEq(16*key+4*((i+j)%4)+j);
			Eq[pos++]=addEq(tmp,tmp2);
			freeEq(tmp);
			freeEq(tmp2);
		}
	}
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x8946
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x8936
movl -0x14(%rbp), %edi
shll $0x4, %edi
movl -0x18(%rbp), %eax
shll $0x2, %eax
addl %eax, %edi
addl -0x1c(%rbp), %edi
callq 0x5da0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x6ce0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movl -0x10(%rbp), %edi
shll $0x4, %edi
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
shll $0x2, %edx
addl %edx, %edi
addl -0x1c(%rbp), %edi
callq 0x5da0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6900
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rdi
callq 0x5900
movl -0xc(%rbp), %edi
shll $0x4, %edi
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
shll $0x2, %edx
addl %edx, %edi
addl -0x1c(%rbp), %edi
callq 0x5da0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6900
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rdi
callq 0x5900
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8844
jmp 0x8938
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8833
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: NewSolver
Solver NewSolver(void) // Renvoi l'adresse d'une SOLVER disponible
{
	static int Initialiser_Espace = 1;
		
	if (Nombre_de_Solver_disponible_pour_allocation) return Espace_Solver_pour_allocation[--Nombre_de_Solver_disponible_pour_allocation];
	else
	{
		if (Initialiser_Espace)
		{
			Initialiser_Espace = 0;
			Espace_Solver_pour_allocation = malloc(Taille_bloc_pour_allocation_Espace*sizeof(Solver));
			Taille_Espace_Solver_pour_allocation = Taille_bloc_pour_allocation_Espace;
		}
		SOLVER * __restrict tmp = malloc(Taille_bloc_pour_allocation_Espace*sizeof(SOLVER));
		int i;
		for (i = 0; i < Taille_bloc_pour_allocation_Espace; i++)
		{
			Espace_Solver_pour_allocation[i]=tmp++;
			Espace_Solver_pour_allocation[i]->parents=1;
		}
		Nombre_de_Solver_disponible_pour_allocation = Taille_bloc_pour_allocation_Espace;
		return Espace_Solver_pour_allocation[--Nombre_de_Solver_disponible_pour_allocation];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x34041(%rip)     # 0x3d2d0
je 0x92b7
movq 0x34040(%rip), %rax     # 0x3d2d8
movl 0x34032(%rip), %ecx     # 0x3d2d0
addl $-0x1, %ecx
movl %ecx, 0x34029(%rip)     # 0x3d2d0
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x936d
cmpl $0x0, 0x33ea2(%rip)     # 0x3d160
je 0x92e5
movl $0x0, 0x33e96(%rip)     # 0x3d160
movl $0x13880, %edi          # imm = 0x13880
callq 0x21c0
movq %rax, 0x33ffd(%rip)     # 0x3d2d8
movl $0x2710, 0x33fef(%rip)  # imm = 0x2710
movl $0x75300, %edi          # imm = 0x75300
callq 0x21c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2710, -0x14(%rbp)    # imm = 0x2710
jge 0x9342
movq -0x10(%rbp), %rdx
movq %rdx, %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movq 0x33fbf(%rip), %rax     # 0x3d2d8
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x33fb0(%rip), %rax     # 0x3d2d8
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x1c(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x92fa
movl $0x2710, 0x33f84(%rip)  # imm = 0x2710
movq 0x33f85(%rip), %rax     # 0x3d2d8
movl 0x33f77(%rip), %ecx     # 0x3d2d0
addl $-0x1, %ecx
movl %ecx, 0x33f6e(%rip)     # 0x3d2d0
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: freeSolver
void freeSolver(Solver a) // libère la mémoire associée à une solver
{
	if (a!=NULL)
	{
		if (a->parents==1) // elle n'est plus utilisée
		{
			if (Taille_Espace_Solver_pour_allocation == Nombre_de_Solver_disponible_pour_allocation)
			{
				Taille_Espace_Solver_pour_allocation+= Taille_bloc_pour_allocation_Espace;
				Espace_Solver_pour_allocation = realloc(Espace_Solver_pour_allocation, Taille_Espace_Solver_pour_allocation*sizeof(Solver));
			}
			Espace_Solver_pour_allocation[Nombre_de_Solver_disponible_pour_allocation++]=a;
			free(a->var);
			freeSolver(a->fils1);
			freeSolver(a->fils2);
		}
		else (a->parents)--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x946c
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1c(%rax)
jne 0x945d
movl 0x33ef9(%rip), %eax     # 0x3d2d4
cmpl 0x33eef(%rip), %eax     # 0x3d2d0
jne 0x9412
movl 0x33eeb(%rip), %eax     # 0x3d2d4
addl $0x2710, %eax           # imm = 0x2710
movl %eax, 0x33ee0(%rip)     # 0x3d2d4
movq 0x33edd(%rip), %rdi     # 0x3d2d8
movslq 0x33ed2(%rip), %rsi     # 0x3d2d4
shlq $0x3, %rsi
callq 0x21f0
movq %rax, 0x33ec6(%rip)     # 0x3d2d8
movq -0x8(%rbp), %rdx
movq 0x33ebb(%rip), %rax     # 0x3d2d8
movl 0x33ead(%rip), %ecx     # 0x3d2d0
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x33ea2(%rip)     # 0x3d2d0
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x93b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x93b0
jmp 0x946a
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x946c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: print_solver
void print_solver(FILE *out, Solver B, string_list_t *variable_names) // crée le xml associé à une solver
{
  int i;

  fprintf(out,"<solver>\n");
  fprintf(out,"  <time>%d</time>\n",  B->temps);
  fprintf(out,"  <memory>%d</memory>\n", B->memoire);
  fprintf(out,"  <output>%d</output>\n", B->sortie);
  fprintf(out,"  <type>%d</type>\n", B->type);
  fprintf(out,"  <variables>");
  for(i=0; i<B->Nvar; i++)
    fprintf(out,"  <variable>%s</variable>\n", find_var_name(variable_names, B->var[i]));
  fprintf(out,"</variables>\n");
  if (B->fils1 != NULL) print_solver(out, B->fils1, variable_names);
  if (B->fils2 != NULL) print_solver(out, B->fils2, variable_names);
  fprintf(out,"</solver>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2b995(%rip), %rsi     # 0x351c4
movb $0x0, %al
callq 0x2180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x2b986(%rip), %rsi     # 0x351ce
movb $0x0, %al
callq 0x2180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x2b980(%rip), %rsi     # 0x351e1
movb $0x0, %al
callq 0x2180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x2b97e(%rip), %rsi     # 0x351f8
movb $0x0, %al
callq 0x2180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x18(%rax), %edx
leaq 0x2b97b(%rip), %rsi     # 0x3520f
movb $0x0, %al
callq 0x2180
movq -0x8(%rbp), %rdi
leaq 0x2b97c(%rip), %rsi     # 0x35222
movb $0x0, %al
callq 0x2180
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x98ff
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x12fc0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x2b943(%rip), %rsi     # 0x35230
movb $0x0, %al
callq 0x2180
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x98b4
movq -0x8(%rbp), %rdi
leaq 0x2b941(%rip), %rsi     # 0x3524b
movb $0x0, %al
callq 0x2180
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9931
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x9810
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9951
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x9810
movq -0x8(%rbp), %rdi
leaq 0x2b8fd(%rip), %rsi     # 0x35259
movb $0x0, %al
callq 0x2180
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: BaseSolver
Solver BaseSolver(int i, SysEqLin E) // Solver associée à la variable i
{
	if (E->gen*E->lignevar[i]<E->a)
	{
		Solver B = NewSolver();
		B->var=malloc(sizeof(int));
		B->Nvar=1;
		B->var[0]=i;
		#if 0
		B->initialisation=E;
		B->mat=InfoSortie_VariablesVersion(B->var,B->Nvar,E);
		B->sortie=B->mat->nombre_de_lignes-(E->gen-1);
		#else
		B->sortie=TailleE(B->var,1,E);
		#endif
		B->temps=1;
		B->memoire=1; // mettre 0 cause quelques problèmes, en plus il faut bien avoir la table de la Sbox
		B->type=0;
		B->fils1=NULL;
		B->fils2=NULL;
		return B;
	}
	else return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0xc(%rbp), %rdx
imull (%rcx,%rdx,4), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x9b05
callq 0x9280
movq %rax, -0x20(%rbp)
movl $0x4, %edi
callq 0x21c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0xee60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b0d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: SameSolvers
int SameSolvers(Solver B1, Solver B2) // Vrai si les variables des deux solvers sont les mêmes. 
{
	if (B1->Nvar==B2->Nvar)
	{
		if (B1==B2) return 1;
		else
		{
			int i;
			for (i = 0; i < B1->Nvar; i++) if (B1->var[i]!=B2->var[i]) return 0;
			return 1;
		}
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x9b9f
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x9b4f
movl $0x1, -0x4(%rbp)
jmp 0x9ba6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x9b96
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x9b89
movl $0x0, -0x4(%rbp)
jmp 0x9ba6
jmp 0x9b8b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9b56
movl $0x1, -0x4(%rbp)
jmp 0x9ba6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: ParcoursSolver
void ParcoursSolver(Solver B) // Permet de parcourir une solver, utile pour debugguer
{
	printf("Solver (%d || %d || %d) - %d : ",B->temps,B->memoire,B->sortie,B->type);
	PrintVarSolver(B);
	if (B->type!=0)
	{
		printf("Solver 1 (%d || %d || %d) - %d : ",B->fils1->temps,B->fils1->memoire,B->fils1->sortie,B->fils1->type);
		PrintVarSolver(B->fils1);
		printf("Solver 2 (%d || %d || %d) - %d : ",B->fils2->temps,B->fils2->memoire,B->fils2->sortie,B->fils2->type);
		PrintVarSolver(B->fils2);
		int i;
		if (B->fils1->Nvar==1) i = 2; // zap les unions simples
		else
		{
			if (B->fils2->Nvar==1) i = 1;
			else
			{
				printf("Quelle solver : ?");
				scanf("%d",&i);
				getchar();
			}
		}
		if (i==1) ParcoursSolver(B->fils1);
		else ParcoursSolver(B->fils2);
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movsbl 0x18(%rax), %r8d
leaq 0x2b687(%rip), %rdi     # 0x35268
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x9970
movq -0x8(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x0, %eax
je 0x9d0d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movsbl 0x18(%rax), %r8d
leaq 0x2b651(%rip), %rdi     # 0x35288
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9970
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movsbl 0x18(%rax), %r8d
leaq 0x2b62a(%rip), %rdi     # 0x352aa
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9970
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0x9cab
movl $0x2, -0xc(%rbp)
jmp 0x9ce9
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0x9cc2
movl $0x1, -0xc(%rbp)
jmp 0x9ce7
leaq 0x2b603(%rip), %rdi     # 0x352cc
movb $0x0, %al
callq 0x2100
leaq 0x2f084(%rip), %rdi     # 0x38d5b
leaq -0xc(%rbp), %rsi
movb $0x0, %al
callq 0x2220
callq 0x2170
jmp 0x9ce9
cmpl $0x1, -0xc(%rbp)
jne 0x9cfe
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9bb0
jmp 0x9d0b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9bb0
jmp 0x9d0d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: TriFusion1
void TriFusion1(Solver * __restrict B1, const int N) // Trie une liste de solvers selon 1) la sortie dans l'ordre croissant 2) le nombre de variables dans l'ordre décroissant.
{
	if (N>=2)
	{
		Solver * __restrict B=malloc((N/2)*sizeof(Solver));
		TriFusion1_tmp(B1,N,B);
		free(B);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jl 0x9fa9
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x9d20
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: UnionSolver2
Solver UnionSolver2(Solver B1, Solver B2, SysEqLin E) // Retourne la solver B2 -> B1. PEUT PRESENTER DES PROBLEMES SI B1 n B2 NON VIDE.
{
	Solver B = NewSolver();
	B->var=UnionListesTriees(B1->var,B1->Nvar,B2->var,B2->Nvar,&B->Nvar);
	#if 0
	B->initialisation=E;
	B->mat=InfoSortie_UnionVersion(B1,B2,E);
	B->sortie=B->mat->nombre_de_lignes - (E->gen-1)*B->Nvar;
	#else
	B->sortie=TailleE(B->var,B->Nvar,E);
	#endif
	B->temps = max(B2->temps,max(0,B2->sortie)+B1->temps);
	B->memoire=max(B1->memoire,B2->memoire);
	B->type=2;
	B->fils1=copySolver(B1);
	B->fils2=copySolver(B2);
	return B;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x9280
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %r8
addq $0x8, %r8
callq 0x24e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
callq 0xee60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jle 0xaffc
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0xb006
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rdx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jle 0xb023
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0xb04c
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jle 0xb035
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0xb03f
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0xc(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0xb072
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0xb07c
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movb $0x2, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x9380
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x9380
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: MakeSolver1
Solver * MakeSolver1(SysEqLin E, int *N1) // crée la liste réduite des solvers de complexité 1 associée à E
{
	int N=E->a/E->gen; // Nombre de variables qui ne sont pas connues.
	
	Solver * __restrict B1=malloc(N*sizeof(Solver)); // Il y a au plus N solvers 1

	int i;
	for (i = 0; i < N; i++) B1[i]=BaseSolver(E->varligne[i],E);
	
	N=ReduireSolvers(B1,N,E); // On réduite la liste.
	
	//TriFusion1(B1,N); // On la tri. (Pratique pour repérer les solvers 1 de sortie nulle)
	for (i = 0; i < N; i++)
	{
		if (B1[i]->sortie<=0)
		{
			Solver tmp = B1[i];
			B1[i]=B1[0];
			B1[0]=tmp;
			break;
		}
	}
	
	
	#if 0 // Activer pour afficher les solvers 1
	for (i = 0; i < N; i++)
	{
		printf("Solver %d : (%d %d %d) : ",i,B1[i]->temps,B1[i]->memoire,B1[i]->sortie);
		PrintVarSolver(B1[i]);
		#if 0 // Activer pour voir les équations des solvers 1
		if (B1[i]->type!=0)
		{
			SysEqLin F=ExtraireEX2Special(B1[i]->var,B1[i]->Nvar,E);
			Equation *Eq=ConversionSys2(B1[i]->var,B1[i]->Nvar,F);
			if (F->b>0)
			{
				int j;
				printf("Equations : \n");
				for (j = 0; j < F->b; j++)
				{
					PrintEq(Eq[j]);
					freeEq(Eq[j]);
					printf("=");
					if (EstNulEq(Eq[j+F->b])) printf("0");
					else PrintEq(Eq[j+F->b]);
					freeEq(Eq[j+F->b]);
					printf("\n");
				}
			}
			freeSysEq(F);
			free(Eq);
		}
		#endif 
	}
	getchar();
	#endif
	*N1=N;
	return B1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x10(%rcx)
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb3b4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq -0x8(%rbp), %rsi
callq 0x9a40
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb37a
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0xb310
movl %eax, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb425
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x14(%rax)
jg 0xb418
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xb425
jmp 0xb41a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb3ce
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: PropagateSolver
Solver PropagateSolver(Solver B, SysEqLin E, Solver *B1, int N1) // Renvoi la solver B augmentée gratuitement avec le maximum de solvers de la liste B1
{
	Solver B2=copySolver(B);
	int i=0;
	while (i < N1)
	{
		Solver tmp=UnionSolverBorne(B2,B1[i],E,B2->sortie);
		if (tmp==NULL || !PlusInteressant_NoVars(tmp,B2)) // cas où la solver n'est pas améliorée "gratuitement" (cas le plus fréquent)
		{
			freeSolver(tmp);
			i++;
		}
		else
		{
			Solver tmp2=B1[i];
			N1--;
			B1[i]=B1[N1];
			B1[N1]=tmp2;
			if (tmp->Nvar==B2->Nvar) freeSolver(tmp); // cas B1[i] contenue dans B2
			else // cas où l'on améliore "gratuitement" la solver B2
			{
				freeSolver(B2);
				B2=tmp;
				i=0;
			}
			
		}
	}
	return B2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9380
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb571
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
callq 0xac00
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb4e2
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jg 0xb4e2
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0xb4f6
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0xb4e2
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0xb4f6
movq -0x38(%rbp), %rdi
callq 0x93b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb56c
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0xb552
movq -0x38(%rbp), %rdi
callq 0x93b0
jmp 0xb56a
movq -0x28(%rbp), %rdi
callq 0x93b0
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0xb56c
jmp 0xb46b
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)