LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: addAccount
int addAccount(char * name)
{
	pthread_mutex_lock(&addLock);
	
	if (*numAcc>=maxAcc)
	{
		pthread_mutex_unlock(&addLock);
		
		return 1;	
	}
	else if (strlen(name)>maxName)
	{
		pthread_mutex_unlock(&addLock);
		
		return 2;
	}


	else
	{
		int i;
		for (i=0; i<*numAcc && !strcasecmp(accountList[i].accountName,"")==0; i++)
		{
			if (strcasecmp(name, accountList[i].accountName)==0)
			{
				pthread_mutex_unlock(&addLock);
				return 3;
			}
				

		}
		
		strcpy(accountList[i].accountName,name);
		accountList[i].balance=0;
		accountList[i].inUse=0;
		
		int temp=*numAcc;
		temp++;
		*numAcc=temp;
		
		pthread_mutex_unlock(&addLock);
		
		return 0;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x6bcd(%rip), %rdi      # 0x81b0
callq 0x1290
movq 0x6ba9(%rip), %rax      # 0x8198
cmpl $0x14, (%rax)
jl 0x160c
leaq 0x6bb5(%rip), %rdi      # 0x81b0
callq 0x11a0
movl $0x1, -0x4(%rbp)
jmp 0x1754
movq -0x10(%rbp), %rdi
callq 0x10b0
cmpq $0x64, %rax
jbe 0x1633
leaq 0x6b8e(%rip), %rdi      # 0x81b0
callq 0x11a0
movl $0x2, -0x4(%rbp)
jmp 0x1754
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq 0x6b54(%rip), %rdx      # 0x8198
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x19(%rbp)
jge 0x1681
movq 0x6b4c(%rip), %rdi      # 0x81a0
movslq -0x14(%rbp), %rax
imulq $0x6c, %rax, %rax
addq %rax, %rdi
leaq 0x1a11(%rip), %rsi      # 0x3077
callq 0x1040
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x168a
jmp 0x16d2
movq -0x10(%rbp), %rdi
movq 0x6b0b(%rip), %rsi      # 0x81a0
movslq -0x14(%rbp), %rax
imulq $0x6c, %rax, %rax
addq %rax, %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x16c2
leaq 0x6aff(%rip), %rdi      # 0x81b0
callq 0x11a0
movl $0x3, -0x4(%rbp)
jmp 0x1754
jmp 0x16c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x163a
movq 0x6ac7(%rip), %rdi      # 0x81a0
movslq -0x14(%rbp), %rax
imulq $0x6c, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movq 0x6aac(%rip), %rax      # 0x81a0
movslq -0x14(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x64(%rax)
movq 0x6a92(%rip), %rax      # 0x81a0
movslq -0x14(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x68(%rax)
movq 0x6a71(%rip), %rax      # 0x8198
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq 0x6a59(%rip), %rax      # 0x8198
movl %ecx, (%rax)
leaq 0x6a68(%rip), %rdi      # 0x81b0
callq 0x11a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: startAccount
int startAccount(char * name)
{
	int i=0;
	
	for (i=0; i<maxAcc; i++)
	{
		
		if (strcasecmp(name, accountList[i].accountName)==0)
		{
			pthread_mutex_lock(&startLock);
			
			if (accountList[i].inUse==0)
			{
				accountList[i].inUse=1;
				pthread_mutex_unlock(&startLock);
				return i;
			}
			else
			{
				pthread_mutex_unlock(&startLock);
				return -2;
			}

		}
	
	}
	
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x181a
movq -0x10(%rbp), %rdi
movq 0x6a11(%rip), %rsi      # 0x81a0
movslq -0x14(%rbp), %rax
imulq $0x6c, %rax, %rax
addq %rax, %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x180a
leaq 0x6a2d(%rip), %rdi      # 0x81d8
callq 0x1290
movq 0x69e9(%rip), %rax      # 0x81a0
movslq -0x14(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x68(%rax)
jne 0x17f5
movq 0x69d1(%rip), %rax      # 0x81a0
movslq -0x14(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x68(%rax)
leaq 0x69f0(%rip), %rdi      # 0x81d8
callq 0x11a0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1821
leaq 0x69dc(%rip), %rdi      # 0x81d8
callq 0x11a0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1821
jmp 0x180c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x177a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: debitAccount
int debitAccount(int id, float amount)
{
	
	if ((accountList[id].balance)-amount<0)
		return 1;
	else
	{
		accountList[id].balance-=amount;
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq 0x695d(%rip), %rax      # 0x81a0
movslq -0x8(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movss 0x64(%rax), %xmm1
subss -0xc(%rbp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1869
movl $0x1, -0x4(%rbp)
jmp 0x1895
movss -0xc(%rbp), %xmm1
movq 0x692b(%rip), %rax      # 0x81a0
movslq -0x8(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movss 0x64(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x64(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: listenConnection
void listenConnection(int sock)
{
	while (1)
	{
		/* accept incoming connections */
		connection_t *connection = (connection_t *)calloc(3, sizeof(connection_t));
		connection->sock = accept(sock, &connection->address, &connection->addr_len);
		
		if (connection->sock <= 0)
		{
			free(connection);
		}
		else
		{
			if (fork()==0)
			{
				printf("Client Connection Accepted\n");
				int temp2=getpid();
				printf("Process Created with ID : ");
				printf("%i\n", temp2);
				pthread_create(&thread, 0, clientThread, (void *)connection);
				pthread_detach(thread);
				
				struct sockNode *temp=malloc(sizeof(struct sockNode));
				temp->sock=connection->sock;
				temp->next=head;
				head=temp;	
			}
			
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x3, %edi
movl $0x18, %esi
callq 0x1150
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
addq $0x14, %rdx
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x26a5
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x2745
callq 0x1280
cmpl $0x0, %eax
jne 0x2743
leaq 0xa40(%rip), %rdi       # 0x30fa
movb $0x0, %al
callq 0x10e0
callq 0x10a0
movl %eax, -0x14(%rbp)
leaq 0xa46(%rip), %rdi       # 0x3116
movb $0x0, %al
callq 0x10e0
movl -0x14(%rbp), %esi
leaq 0xa50(%rip), %rdi       # 0x3131
movb $0x0, %al
callq 0x10e0
movq -0x10(%rbp), %rcx
leaq 0x5b0d(%rip), %rdi      # 0x8200
xorl %eax, %eax
movl %eax, %esi
leaq -0xe2e(%rip), %rdx      # 0x18d0
callq 0x1210
movq 0x5af6(%rip), %rdi      # 0x8200
callq 0x11d0
movl $0x10, %edi
callq 0x11c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq 0x5a78(%rip), %rcx      # 0x81a8
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x5a65(%rip)      # 0x81a8
jmp 0x2745
jmp 0x265b
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: initConnection
void initConnection()
{
	
	struct sockaddr_in address;
	
	pthread_mutexattr_t addAtt;
	pthread_mutexattr_t addAtt2;

	pthread_mutexattr_init(&addAtt);
	pthread_mutexattr_init(&addAtt2);
	
	pthread_mutexattr_setpshared(&addAtt, PTHREAD_PROCESS_SHARED);
	pthread_mutexattr_setpshared(&addAtt2, PTHREAD_PROCESS_SHARED);

	pthread_mutex_init(&addLock, &addAtt);
	pthread_mutex_init(&startLock, &addAtt2);
	
	sem_init(&semaphore, 0, 0);

	signal(SIGHUP, exitHandler);
	signal(SIGINT, exitHandler);
	
	/* create socket */
	sock = socket(AF_INET, SOCK_STREAM, 0);

	/* bind socket to port */
	address.sin_family = AF_INET;
	address.sin_addr.s_addr = INADDR_ANY;
	address.sin_port = htons(port);

	bind(sock, (struct sockaddr *)&address, sizeof(struct sockaddr_in));
	
	/* listen on port */
	listen(sock, 5);


	printf("Now Accepting Incoming Client Connections...\n");
	
	pthread_create(&lThread, NULL, printAccounts, NULL);
	pthread_detach(lThread);
	
	listenConnection(sock);
	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x14(%rbp), %rdi
callq 0x1260
leaq -0x18(%rbp), %rdi
callq 0x1260
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0x1180
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1180
leaq 0x5a23(%rip), %rdi      # 0x81b0
leaq -0x14(%rbp), %rsi
callq 0x1270
leaq 0x5a3b(%rip), %rdi      # 0x81d8
leaq -0x18(%rbp), %rsi
callq 0x1270
leaq 0x59cb(%rip), %rdi      # 0x8178
xorl %edx, %edx
movl %edx, %esi
callq 0x11f0
movl $0x1, %edi
leaq -0x12a2(%rip), %rsi     # 0x1520
callq 0x1160
movl $0x2, %edi
leaq -0x12b3(%rip), %rsi     # 0x1520
callq 0x1160
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x12a0
movl %eax, 0x5979(%rip)      # 0x8168
movw $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl 0x596a(%rip), %eax      # 0x816c
movzwl %ax, %edi
callq 0x10d0
movw %ax, -0xe(%rbp)
movl 0x5954(%rip), %edi      # 0x8168
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x1200
movl 0x5940(%rip), %edi      # 0x8168
movl $0x5, %esi
callq 0x11e0
leaq 0x8fc(%rip), %rdi       # 0x3135
movb $0x0, %al
callq 0x10e0
leaq 0x59c1(%rip), %rdi      # 0x8208
xorl %eax, %eax
movl %eax, %ecx
leaq -0x1482(%rip), %rdx     # 0x13d0
movq %rcx, %rsi
callq 0x1210
movq 0x59a7(%rip), %rdi      # 0x8208
callq 0x11d0
movl 0x58fc(%rip), %edi      # 0x8168
callq 0x2650
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: main
int main(int argc, char ** argv)
{
	accountList = mmap(NULL, maxAcc*sizeof(account), PROT_READ | PROT_WRITE, 
                    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
        numAcc = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, 
                    MAP_SHARED | MAP_ANONYMOUS, -1, 0);

	struct sigaction sa;
	sa.sa_handler = SIG_IGN;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;

	if (sigaction(SIGCHLD, &sa, 0) == -1) 
	{
  		perror(0);
  		exit(1);
	}

	initConnection();
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %r9d
movl $0x870, %esi            # imm = 0x870
movl $0x3, %edx
movl $0x21, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10c0
movq %rax, 0x58de(%rip)      # 0x81a0
xorl %eax, %eax
movl %eax, %r9d
movl $0x4, %esi
movl $0x3, %edx
movl $0x21, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10c0
movq %rax, 0x58ad(%rip)      # 0x8198
movl $0x1, %eax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1170
movl $0x0, -0x20(%rbp)
movl $0x11, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1070
cmpl $-0x1, %eax
jne 0x293b
xorl %eax, %eax
movl %eax, %edi
callq 0x1220
movl $0x1, %edi
callq 0x1250
callq 0x2750
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x800, %edi            # imm = 0x800
callq 0x21c0
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x23da
movl $0x100, %edi            # imm = 0x100
callq 0x21c0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23ad
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x24ad
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jge 0x249d
movl -0x4(%rbp), %eax
movb %al, -0xd(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0xe(%rbp)
movb $0x0, -0xf(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x0, %eax
je 0x2466
movzbl -0xd(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2433
movzbl -0xf(%rbp), %eax
movzbl -0xe(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0xf(%rbp)
movzbl -0xe(%rbp), %eax
andl $0x80, %eax
movb %al, -0x10(%rbp)
movzbl -0xe(%rbp), %eax
shll %eax
movb %al, -0xe(%rbp)
movzbl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x245b
movzbl -0xe(%rbp), %eax
xorl $0x1b, %eax
movb %al, -0xe(%rbp)
movzbl -0xd(%rbp), %eax
sarl %eax
movb %al, -0xd(%rbp)
jmp 0x2411
movb -0xf(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x23f4
jmp 0x249f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x23e1
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: UnionListesTriees2
int UnionListesTriees2(int * const L1, const int t1, int * const L2, const int t2, int * const Final)
{
	int i=0, j=0, cpt=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]<L2[j]) Final[cpt++]=L1[i++];
		else
		{
			if (L1[i]==L2[j]) i++;
			Final[cpt++]=L2[j++];
		}
	}
	for (i = i; i < t1; i++) Final[cpt++]=L1[i];
	for (j = j; j < t2; j++) Final[cpt++]=L2[j];
	return cpt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x35(%rbp)
jge 0x26e4
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x26f0
jmp 0x2784
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x30(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2734
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x277f
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x30(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2755
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x30(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x26cb
movl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27bd
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x278a
movl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x27f6
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x27c3
movl -0x34(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2834
cmpl $0x0, -0x24(%rbp)
jne 0x282b
movl $0x0, -0x4(%rbp)
jmp 0x2886
movl $0x1, -0x4(%rbp)
jmp 0x2886
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x284b
movl $0x1, -0x4(%rbp)
jmp 0x2886
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2862
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
callq 0x2800
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x291a
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x2920
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl $0x0, %eax
jle 0x2946
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2938
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x293e
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x294d
xorl %eax, %eax
movl %eax, -0x48(%rbp)
jmp 0x294d
movl -0x48(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x49(%rbp)
jge 0x298e
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x2997
jmp 0x2a0a
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x29ba
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2a05
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x29fc
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x3c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2975
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x2a48
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x2a4f
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x2a4f
movl -0x40(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x41(%rbp)
jge 0x2a90
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2a99
jmp 0x2b0c
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2add
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x3c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2b07
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2afe
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2a77
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2b45
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x3c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2b12
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: SearchElement
int SearchElement(const int a, int * __restrict const L, const int N)
{
	int debut = 0, fin = N;
	while (debut<fin)
	{
		const int pivot=(debut+fin)/2;
		if (L[pivot]==a) return pivot;
		if (L[pivot]>a) fin=pivot;
		else debut=pivot+1;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2bcf
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x2bac
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2bd6
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jle 0x2bc4
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2bcd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b7b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: compare_ints
int compare_ints( const void* a, const void* b )
{
     int* arg1 = (int*) a;
     int* arg2 = (int*) b;
     if( *arg1 < *arg2 ) return -1;
     else if( *arg1 == *arg2 ) return 0;
     else return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2c13
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c31
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x2c2a
movl $0x0, -0x4(%rbp)
jmp 0x2c31
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: compare_ints_special
int compare_ints_special(const void* a, const void *b)
{
     int* arg1 = (int*) a;
     int* arg2 = (int*) b;
     if( Liste_Globale[*arg1] < Liste_Globale[*arg2] ) return -1;
     else if( Liste_Globale[*arg1] == Liste_Globale[*arg2] ) return 0;
     else return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x3a3ed(%rip), %rax     # 0x3d2c0
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %eax
movq 0x3a3dc(%rip), %rcx     # 0x3d2c0
movq -0x28(%rbp), %rdx
movslq (%rdx), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2ef9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2d
movq 0x3a3c0(%rip), %rax     # 0x3d2c0
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %eax
movq 0x3a3af(%rip), %rcx     # 0x3d2c0
movq -0x28(%rbp), %rdx
movslq (%rdx), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2f26
movl $0x0, -0x4(%rbp)
jmp 0x2f2d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x3234
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x2b60
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x31d6
movl $0x0, -0x4(%rbp)
jmp 0x3278
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %r8
movslq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %r8
movl -0x14(%rbp), %r9d
subl -0x30(%rbp), %r9d
movq -0x20(%rbp), %r10
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
addq %rax, %r10
movl -0x24(%rbp), %eax
subl -0x34(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3290
movl %eax, -0x4(%rbp)
jmp 0x3278
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3271
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x3264
movl $0x0, -0x4(%rbp)
jmp 0x3278
jmp 0x3266
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x323b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x32d3
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq 0x10(%rbp), %rdx
movl 0x18(%rbp), %ecx
callq 0x3360
movl %eax, -0x4(%rbp)
jmp 0x3350
cmpl $0x0, -0x34(%rbp)
jg 0x32f1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x3360
movl %eax, -0x4(%rbp)
jmp 0x3350
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x3349
movl -0x34(%rbp), %eax
cmpl 0x18(%rbp), %eax
jg 0x3349
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x3180
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x35(%rbp)
je 0x333c
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq 0x10(%rbp), %rdx
movl 0x18(%rbp), %ecx
callq 0x3180
cmpl $0x0, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3350
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: IntersectionNonVideListeTriees
int IntersectionNonVideListeTriees(int * const L1, const int t1, int * const L2, const int t2)
{
	int i=0,j=0;
	while (i<t1 && j<t2)
	{
		if (L1[i]==L2[j]) return 1;
		else
		{
			if (L1[i]<L2[j]) i++;
			else j++;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x33f9
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x3402
jmp 0x3453
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x3423
movl $0x1, -0x4(%rbp)
jmp 0x345a
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x3446
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x344f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3451
jmp 0x33e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: Puissance
int Puissance(const int a, const int b) /* a puissance b */
{
	if (b==0) return 1;
	int c=Puissance(a,b/2);
	if (b & 1) return c*c;
	else return c*c*a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x347d
movl $0x1, -0x4(%rbp)
jmp 0x34ba
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x3460
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x34ac
movl -0x10(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x34ba
movl -0x10(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Bazar.c
// Function: NextSet
int NextSet(int * X, int l, int n)
{
	int i;
	for (i = 1; i <= l; i++)
	{
		if (X[l-i]!=n-i)
		{
			int j;
			int add = ++X[l-i];
			for (j = l-i+1; j < l; j++) X[j] = ++add;
			return 1;
		}
	}
			
	for (i = 0; i < l; i++) X[i]=i;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x356c
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
je 0x355c
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
movl (%rcx,%rdx,4), %eax
addl $0x1, %eax
movl %eax, (%rcx,%rdx,4)
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3553
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x352c
movl $0x1, -0x4(%rbp)
jmp 0x359b
jmp 0x355e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x34e5
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3594
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3573
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x35fd
movl -0x8(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x35fd
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3693
movl -0x8(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3693
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3691
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x1d(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x362c
jmp 0x3693
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3716
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x36fd
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x31a25(%rip), %rdi     # 0x35110
movb $0x0, %al
callq 0x2100
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x36c8
leaq 0x337d3(%rip), %rdi     # 0x36ed7
movb $0x0, %al
callq 0x2100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x36b9
leaq 0x337ba(%rip), %rdi     # 0x36ed7
movb $0x0, %al
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3b32
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3930
movl %eax, -0x4(%rbp)
jmp 0x3bfc
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3bd2
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %eax
imull -0x18(%rbp), %eax
cltq
addq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3bc5
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3b8c
jmp 0x3bc7
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3b61
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3930
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x436d
movslq -0x34(%rbp), %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4318
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x42df
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x435d
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x3c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x431f
jmp 0x435f
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x42b0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x34(%rbp), %ecx
callq 0x3c10
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x43ae
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x438a
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4aae
movl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x4a7f
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x4a85
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4a67
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
callq 0x43c0
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x3c10
movl %eax, -0x3c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4b0e
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4aea
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x546e
movl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x543f
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x5445
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5427
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
callq 0x4b20
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x3c10
movl %eax, -0x3c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x54ce
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x54aa
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq