LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/salextpuru[P]speccy-toochain/src/megalz/MegaLZ_twobyters.c
// Function: cutoff_twobyte_chain
void cutoff_twobyte_chain(ULONG index,ULONG curpos)
{ // cuts off given chain so that there are no older than 4352 bytes back elements

	struct tb_chain * curr, * prev;


	curr=tb_entry[index];
	if( !curr ) return;

	// see if we should delete elements after first element in the given chain
	prev=curr;
	curr=curr->next;

	while( curr )
	{
		if( (curpos-(curr->pos))>4352 )
		{
			prev->next=curr->next; // remove from chain

			curr->next=tb_free; // insert into free chain
			tb_free=curr;

			curr=prev->next; // step to the next element in chain
		}
		else
		{
			prev=curr;
			curr=curr->next;
		}
	}

	// delete first element in chain if needed
	curr=tb_entry[index];
	if( (curpos-(curr->pos))>4352 )
	{
		tb_entry[index]=curr->next;
		curr->next=tb_free;
		tb_free=curr;
	}
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x4f3b(%rip), %rax      # 0x8650
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x372b
jmp 0x380d
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x37b0
movl -0x8(%rsp), %eax
movq -0x10(%rsp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x1100, %eax           # imm = 0x1100
jbe 0x3797
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x4ecc(%rip), %rcx      # 0x8640
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq %rax, 0x4eb8(%rip)      # 0x8640
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x37ae
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x3742
movl -0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x4e93(%rip), %rax      # 0x8650
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rsp)
movl -0x8(%rsp), %eax
movq -0x10(%rsp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x1100, %eax           # imm = 0x1100
jbe 0x380d
movq -0x10(%rsp), %rax
movq (%rax), %rdx
movl -0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x4e62(%rip), %rax      # 0x8650
movq %rdx, (%rax,%rcx,8)
movq 0x4e47(%rip), %rcx      # 0x8640
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq %rax, 0x4e33(%rip)      # 0x8640
retq
nop
// File: /workspace/github_c_makefile_star2_O0/salextpuru[P]speccy-toochain/src/megalz/MegaLZ_twobyters.c
// Function: add_bunch_of_twobyters
ULONG add_bunch_of_twobyters(void)
{ // adds a bunch of twobyters to the free list

	ULONG i;
	struct tb_bunch * newbunch;

	// alloc new bunch
	newbunch=(struct tb_bunch *)malloc( sizeof(struct tb_bunch) );
	if( newbunch==NULL ) return 0;

	// link every twobyter into one list
	for(i=0;i<(BUNCHSIZE-1);i++)
	{
		newbunch->bunch[i].next=&(newbunch->bunch[i+1]);
	}

	// add this list to the free list
	newbunch->bunch[BUNCHSIZE-1].next=tb_free;
	tb_free=&(newbunch->bunch[0]);

	// add bunch to bunches list
	newbunch->next=tb_bunches;
	tb_bunches=newbunch;

	return 1;
}

// Assembly:
subq $0x18, %rsp
movl $0x1008, %edi           # imm = 0x1008
callq 0x10e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3838
movl $0x0, 0x14(%rsp)
jmp 0x38cd
movl $0x0, 0x10(%rsp)
cmpl $0xff, 0x10(%rsp)
jae 0x3887
movq 0x8(%rsp), %rcx
addq $0x8, %rcx
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x8, %rax
movl 0x10(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3840
movq 0x4db2(%rip), %rcx      # 0x8640
movq 0x8(%rsp), %rax
movq %rcx, 0xff8(%rax)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x4d96(%rip)      # 0x8640
movq 0x4d97(%rip), %rcx      # 0x8648
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x4d83(%rip)      # 0x8648
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/lodepng/lodepng.c
// Function: update_adler32
static unsigned update_adler32(unsigned adler, const unsigned char* data, unsigned len)
{
  unsigned s1 = adler & 0xffff;
  unsigned s2 = (adler >> 16) & 0xffff;

  while(len > 0)
  {
    /*at least 5552 sums can be done before the sums overflow, saving a lot of module divisions*/
    unsigned amount = len > 5552 ? 5552 : len;
    len -= amount;
    while(amount > 0)
    {
      s1 += (*data++);
      s2 += s1;
      --amount;
    }
    s1 %= 65521;
    s2 %= 65521;
  }

  return (s2 << 16) | s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0xdfbc
cmpl $0x15b0, -0x14(%rbp)    # imm = 0x15B0
jbe 0xdf50
movl $0x15b0, %eax           # imm = 0x15B0
movl %eax, -0x24(%rbp)
jmp 0xdf56
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x20(%rbp)
jbe 0xdf99
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdf67
movl -0x18(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rbp)
jmp 0xdf37
movl -0x1c(%rbp), %eax
shll $0x10, %eax
orl -0x18(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/lodepng/lodepng.c
// Function: lodepng_pixel_overflow
static int lodepng_pixel_overflow(unsigned w, unsigned h,
                                  const LodePNGColorMode* pngcolor, const LodePNGColorMode* rawcolor)
{
  size_t bpp = LODEPNG_MAX(lodepng_get_bpp(pngcolor), lodepng_get_bpp(rawcolor));
  size_t numpixels, total;
  size_t line; /* bytes per line in worst case */

  if(lodepng_mulofl((size_t)w, (size_t)h, &numpixels)) return 1;
  if(lodepng_mulofl(numpixels, 8, &total)) return 1; /* bit pointer with 8-bit color, or 8 bytes per channel color */

  /* Bytes per scanline with the expression "(w / 8) * bpp) + ((w & 7) * bpp + 7) / 8" */
  if(lodepng_mulofl((size_t)(w / 8), bpp, &line)) return 1;
  if(lodepng_addofl(line, ((w & 7) * bpp + 7) / 8, &line)) return 1;

  if(lodepng_addofl(line, 5, &line)) return 1; /* 5 bytes overhead per line: 1 filterbyte, 4 for Adam7 worst case */
  if(lodepng_mulofl(line, h, &total)) return 1; /* Total bytes in worst case */

  return 0; /* no overflow */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30d0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jbe 0xe302
movq -0x18(%rbp), %rdi
callq 0x30d0
movl %eax, -0x48(%rbp)
jmp 0xe30e
movq -0x20(%rbp), %rdi
callq 0x30d0
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %edi
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdx
callq 0xf510
cmpl $0x0, %eax
je 0xe33b
movl $0x1, -0x4(%rbp)
jmp 0xe3fc
movq -0x30(%rbp), %rdi
movl $0x8, %esi
leaq -0x38(%rbp), %rdx
callq 0xf510
cmpl $0x0, %eax
je 0xe35e
movl $0x1, -0x4(%rbp)
jmp 0xe3fc
movl -0x8(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
movl %eax, %edi
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xf510
cmpl $0x0, %eax
je 0xe383
movl $0x1, -0x4(%rbp)
jmp 0xe3fc
movq -0x40(%rbp), %rdi
movl -0x8(%rbp), %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %esi
imulq -0x28(%rbp), %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
leaq -0x40(%rbp), %rdx
callq 0xe410
cmpl $0x0, %eax
je 0xe3b5
movl $0x1, -0x4(%rbp)
jmp 0xe3fc
movq -0x40(%rbp), %rdi
movl $0x5, %esi
leaq -0x40(%rbp), %rdx
callq 0xe410
cmpl $0x0, %eax
je 0xe3d5
movl $0x1, -0x4(%rbp)
jmp 0xe3fc
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdx
callq 0xf510
cmpl $0x0, %eax
je 0xe3f5
movl $0x1, -0x4(%rbp)
jmp 0xe3fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/keygen.c
// Function: keygen
struct keygen_t keygen(void)
{ 
  srand(time(0));
  unsigned int p,q, prime = (rand()/RAND_LIMITS)%RAND_LIMITS;
  unsigned long phi, e = 2, n;
  double d = 0;
  struct keygen_t key;
  
  /* Getting prime number */
  p = findNxtPrime(prime);
  q = findNxtPrime(p+2);
  n = p*q;
  /* finding e and d value for rsa*/
  phi = (p-1)*(q-1);
  while(gcd(phi,e)!=1) e++;
  d = mod_inverse(e, phi);

  printf("Prime No.    -> p: %u q: %u\n",p, q);
  printf("n, phi Value -> n: %lu phi: %lu\n",n, phi);
  printf("e, d Value   -> e: %lu d: %.2f\n", e, d);
  printf("d<phi-> %d\n", d<phi);
  key.pub.val = e, key.pub.n = n;
  key.pri.val = d, key.pri.n = n;
  return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movl %eax, %edi
callq 0x1060
callq 0x1090
movl $0xffff, %ecx           # imm = 0xFFFF
cltd
idivl %ecx
movl $0xffff, %ecx           # imm = 0xFFFF
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movq $0x2, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
callq 0x1580
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1580
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1530
cmpq $0x1, %rax
je 0x124a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1229
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15e0
movsd %xmm0, -0x30(%rbp)
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0xdc7(%rip), %rdi       # 0x2030
xorl %eax, %eax
movb %al, -0x41(%rbp)
callq 0x1040
movb -0x41(%rbp), %al
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xdc8(%rip), %rdi       # 0x204d
callq 0x1040
movq -0x20(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
leaq 0xdd4(%rip), %rdi       # 0x206e
movb $0x1, %al
callq 0x1040
movsd -0x30(%rbp), %xmm1
movaps 0xd63(%rip), %xmm2      # 0x2010
movq -0x18(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xd62(%rip), %xmm2      # 0x2020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %esi
leaq 0xdae(%rip), %rdi       # 0x208e
movb $0x0, %al
callq 0x1040
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x28(%rbp), %rdx
movq %rdx, 0x8(%rcx)
cvttsd2si -0x30(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movq -0x28(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/rsa_crypto.c
// Function: encrypt
int encrypt(long long *en, const char * msg,struct key_t pub, size_t len)
{
  if(NULL == msg){
    printf("Error: empty message pass\n");
    return -1;
  }
  int i;
  for(i=0; i<len; i++){
    en[i] = mod_cal(msg[i], pub.val, pub.n);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x135b
leaq 0xd4f(%rip), %rdi       # 0x209a
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13a9
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x13a2
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbq (%rax,%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
callq 0x1690
movq %rax, %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 0x1362
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/rsa_crypto.c
// Function: decrypt
int decrypt(char *msg, const long long * cipher,struct key_t pri, size_t len)
{
  if(NULL == cipher){
    printf("Error: empty message pass\n");
    return -1;
  }

  int i;
  for(i=0; i<len; i++){
    msg[i]=0;
    msg[i] = mod_cal(cipher[i], pri.val, pri.n);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x13fb
leaq 0xcaf(%rip), %rdi       # 0x209a
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1452
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x144b
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
callq 0x1690
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1402
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/math.c
// Function: isPrime
int isPrime(long long n)
{
    if (n <= 1)  return 0;
    if (n <= 3)  return 1;

    if (n%2 == 0 || n%3 == 0) return 0;

    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jg 0x147b
movl $0x0, -0x4(%rbp)
jmp 0x151d
cmpq $0x3, -0x10(%rbp)
jg 0x148e
movl $0x1, -0x4(%rbp)
jmp 0x151d
movq -0x10(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x14b6
movq -0x10(%rbp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x14bf
movl $0x0, -0x4(%rbp)
jmp 0x151d
movl $0x5, -0x14(%rbp)
movl -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
cltq
cmpq -0x10(%rbp), %rax
jg 0x1516
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x1500
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x1509
movl $0x0, -0x4(%rbp)
jmp 0x151d
jmp 0x150b
movl -0x14(%rbp), %eax
addl $0x6, %eax
movl %eax, -0x14(%rbp)
jmp 0x14c6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/math.c
// Function: findNxtPrime
long long findNxtPrime(long long num)
{
  if(0 == num%2)
    num+=1;
  while(!isPrime(num)) num+=2;
  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
xorl %eax, %eax
cmpq %rdx, %rax
jne 0x15ad
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x15af
movq -0x8(%rbp), %rdi
callq 0x1460
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15c6
jmp 0x15d4
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x15af
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/math.c
// Function: mod_inverse
double mod_inverse(unsigned long a, unsigned long m)
{
  int m0 = m;
  int y = 0, x =1;

  if(m==1)
    return 0;

  while(a>1)
  {
    // q is quotient
    int q = a/m;
    int t = m;

    //m is remainder now, process same as
    //Euclid's algo
    m = a%m, a = t;
    t = y;

    //update y and x
    y = x - q*y;
    x =t;
  }

  //make x positive
  if(x <0)
    x += m0;
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x1612
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x167f
jmp 0x1614
cmpq $0x1, -0x10(%rbp)
jbe 0x1666
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
imull -0x20(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1614
cmpl $0x0, -0x24(%rbp)
jge 0x1675
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cvtsi2sdl -0x24(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/rsa/math.c
// Function: mod_util
static long long _mod_util(long long a,unsigned long long *buff, long long x, int n)
{
  /* [(a mod n)*(b mod n)] mod n = (a*b)mod n */
  if(x<0)
    return 1;
  if(x<MAX_SIZE){
    if(buff[x]){
      return buff[x];
    }
    else {
      if(x == 0){
        buff[x] = 1;
        return buff[x];
      }
      if(x == 1){
        buff[x] =  a%n;
        return buff[x];
      }
      buff[x] = ((_mod_util(a, buff, x/2, n)*_mod_util(a, buff, x - x/2,n))%(long long)n);
      return buff[x];
    }
  }
  return ((_mod_util(a, buff, x/2, n)*_mod_util(a, buff, x - x/2,n))%(long long)n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x170b
movq $0x1, -0x8(%rbp)
jmp 0x188c
cmpq $0xfa0, -0x20(%rbp)     # imm = 0xFA0
jge 0x1822
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x173d
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x188c
cmpq $0x0, -0x20(%rbp)
jne 0x1769
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x1, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x188c
cmpq $0x1, -0x20(%rbp)
jne 0x179e
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cqto
idivq %rcx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x188c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdx
movl -0x24(%rbp), %ecx
callq 0x16e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq -0x38(%rbp), %rdx
subq %rax, %rdx
movl -0x24(%rbp), %ecx
callq 0x16e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
imulq %rcx, %rax
movslq -0x24(%rbp), %rcx
cqto
idivq %rcx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x188c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdx
movl -0x24(%rbp), %ecx
callq 0x16e0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq -0x48(%rbp), %rdx
subq %rax, %rdx
movl -0x24(%rbp), %ecx
callq 0x16e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
imulq %rcx, %rax
movslq -0x24(%rbp), %rcx
cqto
idivq %rcx
movq %rdx, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/io_test.c
// Function: test_io_write_vector_to_file
void test_io_write_vector_to_file(void) {
	Vector vec = vector_create(0, NULL);
	vector_insert_last(vec, "foo");
	vector_insert_last(vec, "bar");

	// δημιουργία ενός προσωρινού αρχείου
	TEST_ASSERT(io_write_vector_to_file("io_tests_temp", vec) > 0);

	vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x52b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1eef(%rip), %rsi      # 0x62e1
callq 0x5450
movq -0x8(%rbp), %rdi
leaq 0x1ee3(%rip), %rsi      # 0x62e5
callq 0x5450
movq -0x8(%rbp), %rsi
leaq 0x1ed7(%rip), %rdi      # 0x62e9
callq 0x5250
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1ece(%rip), %rsi      # 0x62f7
movl $0x13, %edx
leaq 0x2052(%rip), %rcx      # 0x6487
leaq 0x1ec5(%rip), %r8       # 0x6301
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x444d
callq 0x2e80
jmp 0x444f
movq -0x8(%rbp), %rdi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/io_test.c
// Function: test_io_read_file_as_vector
void test_io_read_file_as_vector(void) {
	Vector vec = io_read_file_as_vector("io_tests_temp");
	TEST_ASSERT(vec != NULL);

	TEST_ASSERT(strcmp(vector_get_at(vec, 0), "foo") == 0);
	TEST_ASSERT(strcmp(vector_get_at(vec, 1), "bar") == 0);

	// διαγραφή του προσωρινού αρχείου
	remove("io_tests_temp");

	TEST_ASSERT(io_read_file_as_vector("a_file_that_doesnt_exist") == NULL);

	vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1e7a(%rip), %rdi      # 0x62e9
callq 0x5170
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1e6b(%rip), %rsi      # 0x62f7
movl $0x1a, %edx
leaq 0x1fef(%rip), %rcx      # 0x6487
leaq 0x1e94(%rip), %r8       # 0x6333
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x44b0
callq 0x2e80
jmp 0x44b2
jmp 0x44b4
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5350
movq %rax, %rdi
leaq 0x1e18(%rip), %rsi      # 0x62e1
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1e17(%rip), %rsi      # 0x62f7
movl $0x1c, %edx
leaq 0x1f9b(%rip), %rcx      # 0x6487
leaq 0x1e4c(%rip), %r8       # 0x633f
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4504
callq 0x2e80
jmp 0x4506
jmp 0x4508
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5350
movq %rax, %rdi
leaq 0x1dc5(%rip), %rsi      # 0x62e5
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1dc0(%rip), %rsi      # 0x62f7
movl $0x1d, %edx
leaq 0x1f44(%rip), %rcx      # 0x6487
leaq 0x1e1f(%rip), %r8       # 0x6369
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x455b
callq 0x2e80
jmp 0x455d
leaq 0x1d85(%rip), %rdi      # 0x62e9
callq 0x2060
leaq 0x1e23(%rip), %rdi      # 0x6393
callq 0x5170
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1d6f(%rip), %rsi      # 0x62f7
movl $0x22, %edx
leaq 0x1ef3(%rip), %rcx      # 0x6487
leaq 0x1e11(%rip), %r8       # 0x63ac
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x45ac
callq 0x2e80
jmp 0x45ae
movq -0x8(%rbp), %rdi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/mkdir.c
// Function: main
int main(int argc, char **argv)
{
	if(argc == 1){
		printf("what do you want? \n");
		return 0;
	}
	else if(argc > 2){
		printf("how many arguments :/ \n");
		return 0;
	}
	struct stat st = {0};
	if(stat(argv[1], &st) == -1)
	{
		mkdir(argv[1], 0700);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11a6
leaq 0xe6e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x120a
cmpl $0x2, -0x8(%rbp)
jle 0x11c3
leaq 0xe65(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x120a
jmp 0x11c5
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1060
cmpl $-0x1, %eax
jne 0x1203
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch2/eatyguy1.c
// Function: set_color
int set_color(lua_State *L) {
  int color = lua_tonumber(L, 1);
  char cmd[1024];
  snprintf(cmd, 1024, "tput setab %d", color);
  system(cmd);
  return 0;  // 0 is the number of Lua-visible return values.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6270
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
leaq -0x410(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x400, %esi            # imm = 0x400
leaq 0x2d9f6(%rip), %rdx     # 0x33004
movb $0x0, %al
callq 0x5180
leaq -0x410(%rbp), %rdi
callq 0x5150
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch2/eatyguy1.c
// Function: main
int main() {

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "eatyguy1.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  // Make the set_color function visible to Lua.
  lua_pushcfunction(L, set_color);
  lua_setglobal(L, "set_color");

  // Run the init() function.
  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x213d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21790
movq -0x10(%rbp), %rdi
leaq 0x2d9b6(%rip), %rsi     # 0x33012
xorl %eax, %eax
movl %eax, %edx
callq 0x208a0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x5694
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movq %r9, %r8
callq 0x7e30
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdi
leaq 0x2d97d(%rip), %rsi     # 0x3301f
callq 0x7400
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x59e0
movq -0x10(%rbp), %rdi
leaq -0xed(%rip), %rsi       # 0x55d0
xorl %edx, %edx
callq 0x6ac0
movq -0x10(%rbp), %rdi
leaq 0x2d958(%rip), %rsi     # 0x33027
callq 0x7400
movq -0x10(%rbp), %rdi
leaq 0x2d940(%rip), %rsi     # 0x3301f
callq 0x6cd0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2d93d(%rip), %rdx     # 0x33031
callq 0x6f10
movq -0x10(%rbp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x7d60
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_save2.c
// Function: ft_save2
void	ft_save2(t_map *map, int fd)
{
	int	file_size;
	int	offset;
	int	size;
	int	nbr_plan;
	int	end;

	end = -1;
	nbr_plan = 1;
	offset = 58;
	file_size = (map->res_y * map->res_x * 4) + 58;
	size = 40;
	write(fd, "BM", 2);
	write(fd, &file_size, 4);
	write(fd, "\0\0\0\0", 4);
	write(fd, &offset, 4);
	write(fd, &size, 4);
	write(fd, &map->res_x, 4);
	write(fd, &map->res_y, 4);
	write(fd, &nbr_plan, 2);
	write(fd, &map->mlx.img->bpp, 2);
	while (++end < 28)
		write(fd, "\0", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1c(%rbp)
movl $0x3a, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x18(%rcx), %eax
shll $0x2, %eax
addl $0x3a, %eax
movl %eax, -0x10(%rbp)
movl $0x28, -0x18(%rbp)
movl -0xc(%rbp), %edi
leaq 0x5e43(%rip), %rsi      # 0x11bb0
movl $0x2, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
leaq 0x5e21(%rip), %rsi      # 0x11bb3
movl $0x4, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x4, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
addq $0x1c, %rsi
movl $0x4, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x2, %edx
callq 0x73d0
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rsi
addq $0x1c, %rsi
movl $0x2, %edx
callq 0x73d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x1c, %eax
jge 0xbe39
movl -0xc(%rbp), %edi
leaq 0x5d8b(%rip), %rsi      # 0x11bb8
movl $0x1, %edx
callq 0x73d0
jmp 0xbe15
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_save.c
// Function: ft_save
void	ft_save(t_map *map)
{
	int	*addr;
	int	fd;
	int	y;
	int	x;

	fd = open("img.bmp", O_TRUNC | O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR |
			S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH);
	if (fd == -1)
		return (ft_error5(53));
	ft_save2(map, fd);
	y = map->res_y;
	addr = (int *)map->mlx.img->data;
	while (--y >= 0)
	{
		x = -1;
		while (++x < map->res_x)
			write(fd, &addr[y * map->mlx.img->size_line / 4 + x], 4);
	}
	if (close(fd) == -1)
		return (ft_error5(54));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5d67(%rip), %rdi      # 0x11bba
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x7410
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xbe7c
movl $0x35, %edi
callq 0x8dff
jmp 0xbf1e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbd20
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0xbf07
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xbf05
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rcx
imull 0x18(%rcx), %eax
movl $0x4, %ecx
cltd
idivl %ecx
addl -0x1c(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movl $0x4, %edx
callq 0x73d0
jmp 0xbeba
jmp 0xbea5
movl -0x14(%rbp), %edi
callq 0x7040
cmpl $-0x1, %eax
jne 0xbf1e
movl $0x36, %edi
callq 0x8dff
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_split2.c
// Function: ft_split2
char	**ft_split2(t_map *map, char c)
{
	char	**tab;
	int		i;
	int		j;

	j = -1;
	i = 0;
	tab = NULL;
	if ((tab = malloc(sizeof(char *) * (map->line_map + 1))) == NULL)
		return (NULL);
	while (++j < map->line_map)
	{
		if ((tab[j] = ft_put_in_tab(map->first_map + i, c)) == NULL)
		{
			ft_free2(tab, j);
			return (NULL);
		}
		while (map->first_map[i++] != c)
			;
	}
	tab[j] = NULL;
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x7100
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xbf85
movq $0x0, -0x8(%rbp)
jmp 0xc019
jmp 0xbf87
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0xc001
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0xa8f0
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0xbfd9
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x911b
movq $0x0, -0x8(%rbp)
jmp 0xc019
jmp 0xbfdb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0xbfff
jmp 0xbfdb
jmp 0xbf87
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_sprite.c
// Function: ft_sprite
void	ft_sprite(t_map *map, double *z_buffer)
{
	t_sprite	*temp;

	ft_sprite_distance(map->sprite, map);
	ft_sprite_order(&map->sprite);
	ft_stock_data2(map);
	temp = map->sprite;
	while (temp)
	{
		ft_point_sprite(temp, map);
		--temp->draw_start_x;
		while (++temp->draw_start_x < temp->draw_end_x)
		{
			temp->tex_x = (int)(256 * (temp->draw_start_x - (-temp->sprite_width
			/ 2 + temp->sprite_screen_x)) * 64 / temp->sprite_width) / 256;
			if (temp->transform_y > 0 && temp->draw_start_x > 0 &&
			temp->draw_start_x < map->res_x && temp->transform_y <
			z_buffer[temp->draw_start_x])
				ft_draw_sprite(temp, map);
		}
		temp = temp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xc1c0
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0xc260
movq -0x8(%rbp), %rdi
callq 0xc2e0
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc172
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa426
movq -0x18(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
movq -0x18(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movq -0x18(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jge 0xc161
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subl 0x50(%rcx), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rdx
addl 0x40(%rdx), %ecx
subl %ecx, %eax
shll $0x8, %eax
shll $0x6, %eax
movq -0x18(%rbp), %rcx
cltd
idivl 0x50(%rcx)
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc15c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jle 0xc15c
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xc15c
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm1
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x54(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc15c
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x86d4
jmp 0xc0a1
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc07c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_sprite_clear.c
// Function: ft_sprite_clear
void	ft_sprite_clear(t_sprite *sprite)
{
	t_sprite	*temp;

	temp = NULL;
	while (sprite)
	{
		temp = sprite;
		sprite = sprite->next;
		ft_free(temp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc1ba
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc835
jmp 0xc194
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_sprite_distance.c
// Function: ft_sprite_distance
void	ft_sprite_distance(t_sprite *sprite, t_map *map)
{
	t_sprite	*temp;

	temp = sprite;
	while (temp)
	{
		temp->dist = ((map->player.pos_x - temp->pos_x) * (map->player.pos_x -
		temp->pos_x) + (map->player.pos_y - temp->pos_y) * (map->player.pos_y -
		temp->pos_y));
		temp = temp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc251
movq -0x10(%rbp), %rax
movsd 0x98(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x98(%rax), %xmm2
movq -0x18(%rbp), %rax
subsd 0x8(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0xa0(%rax), %xmm1
movq -0x18(%rbp), %rax
subsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0xa0(%rax), %xmm3
movq -0x18(%rbp), %rax
subsd 0x10(%rax), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc1d4
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_sprite_order.c
// Function: ft_sprite_order
void	ft_sprite_order(t_sprite **sprite)
{
	t_sprite	*temp;
	t_sprite	*temp2;

	temp = NULL;
	temp2 = NULL;
	temp = *sprite;
	temp2 = *sprite;
	while (temp->next)
	{
		if (temp->dist < temp->next->dist)
		{
			ft_change_data_sprite(temp);
			temp = temp2;
		}
		else
			temp = temp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xc2d8
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc2ca
movq -0x10(%rbp), %rdi
callq 0x778e
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xc2d6
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc292
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_stock_data.c
// Function: ft_stock_data
void	ft_stock_data(t_map *map)
{
	if (map->point.side == 0 && map->ray.ray_dir_x < 0)
	{
		map->data = map->img_e->data;
		map->size_line = map->img_e->size_line;
	}
	if (map->point.side == 0 && map->ray.ray_dir_x >= 0)
	{
		map->data = map->img_w->data;
		map->size_line = map->img_w->size_line;
	}
	if (map->point.side == 1 && map->ray.ray_dir_y < 0)
	{
		map->data = map->img_n->data;
		map->size_line = map->img_n->size_line;
	}
	if (map->point.side == 1 && map->ray.ray_dir_y >= 0)
	{
		map->data = map->img_s->data;
		map->size_line = map->img_s->size_line;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x12c(%rax)
jne 0xc382
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0xe0(%rax), %xmm0
jbe 0xc382
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x168(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x12c(%rax)
jne 0xc3d0
movq -0x8(%rbp), %rax
movsd 0xe0(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc3d0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x168(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x12c(%rax)
jne 0xc41a
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0xe8(%rax), %xmm0
jbe 0xc41a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x168(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x12c(%rax)
jne 0xc468
movq -0x8(%rbp), %rax
movsd 0xe8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc468
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x168(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_strcmp.c
// Function: ft_strcmp
int	ft_strcmp(char *s1, char *s2)
{
	int	i;

	i = 0;
	while (s1[i] && s2[i] && s1[i] == s2[i])
		++i;
	return (s1[i] - s2[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xc4cf
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xc4cf
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xc4d8
jmp 0xc4e3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc483
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/ft_wall_hit.c
// Function: ft_wall_hit
void	ft_wall_hit(t_map *map)
{
	while (map->point.hit == 0)
	{
		if (map->point.side_dist_x < map->point.side_dist_y)
		{
			map->point.side_dist_x += map->point.delta_dist_x;
			map->point.map_x += map->point.step_x;
			map->point.side = 0;
		}
		else
		{
			map->point.side_dist_y += map->point.delta_dist_y;
			map->point.map_y += map->point.step_y;
			map->point.side = 1;
		}
		if (map->map[map->point.map_y][map->point.map_x] == '1')
			map->point.hit = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x128(%rax)
jne 0xc606
movq -0x8(%rbp), %rax
movsd 0xf8(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x100(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc581
movq -0x8(%rbp), %rax
movsd 0x108(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0xf8(%rax), %xmm0
movsd %xmm0, 0xf8(%rax)
movq -0x8(%rbp), %rax
movl 0x120(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0xf0(%rax), %ecx
movl %ecx, 0xf0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x12c(%rax)
jmp 0xc5c9
movq -0x8(%rbp), %rax
movsd 0x110(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x100(%rax), %xmm0
movsd %xmm0, 0x100(%rax)
movq -0x8(%rbp), %rax
movl 0x124(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0xf4(%rax), %ecx
movl %ecx, 0xf4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x12c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xf4(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movslq 0xf0(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0xc601
movq -0x8(%rbp), %rax
movl $0x1, 0x128(%rax)
jmp 0xc508
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/init_key.c
// Function: init_key
void	init_key(t_map *map)
{
	map->key.key_a = 0;
	map->key.key_w = 0;
	map->key.key_s = 0;
	map->key.key_d = 0;
	map->key.key_right = 0;
	map->key.key_left = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x140(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x144(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x150(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x154(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/init_player2.c
// Function: init_player2
void	init_player2(t_map *map)
{
	if (map->orientation == 'N')
		map->player.dir_y = -1;
	if (map->orientation == 'N')
		map->player.plane_x = -0.66;
	if (map->orientation == 'S')
		map->player.dir_y = 1;
	if (map->orientation == 'S')
		map->player.plane_x = 0.66;
	if (map->orientation == 'E')
		map->player.dir_x = -1;
	if (map->orientation == 'E')
		map->player.plane_y = 0.66;
	if (map->orientation == 'W')
		map->player.dir_x = 1;
	if (map->orientation == 'W')
		map->player.plane_y = -0.66;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x4e, %eax
jne 0xcd19
movq -0x8(%rbp), %rax
movsd 0x4eb7(%rip), %xmm0     # 0x11bc8
movsd %xmm0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x4e, %eax
jne 0xcd3a
movq -0x8(%rbp), %rax
movsd 0x4e9e(%rip), %xmm0     # 0x11bd0
movsd %xmm0, 0xb8(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x53, %eax
jne 0xcd5b
movq -0x8(%rbp), %rax
movsd 0x4e85(%rip), %xmm0     # 0x11bd8
movsd %xmm0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x53, %eax
jne 0xcd7c
movq -0x8(%rbp), %rax
movsd 0x4e6c(%rip), %xmm0     # 0x11be0
movsd %xmm0, 0xb8(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x45, %eax
jne 0xcd9d
movq -0x8(%rbp), %rax
movsd 0x4e33(%rip), %xmm0     # 0x11bc8
movsd %xmm0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x45, %eax
jne 0xcdbe
movq -0x8(%rbp), %rax
movsd 0x4e2a(%rip), %xmm0     # 0x11be0
movsd %xmm0, 0xc0(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x57, %eax
jne 0xcddf
movq -0x8(%rbp), %rax
movsd 0x4e01(%rip), %xmm0     # 0x11bd8
movsd %xmm0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x57, %eax
jne 0xce00
movq -0x8(%rbp), %rax
movsd 0x4dd8(%rip), %xmm0     # 0x11bd0
movsd %xmm0, 0xc0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/init_player.c
// Function: init_player
void	init_player(t_map *map)
{
	map->player.dir_x = 0;
	map->player.dir_y = 0;
	map->player.plane_x = 0;
	map->player.plane_y = 0;
	init_player2(map);
	map->player.move_speed = 0.05;
	map->player.rotate_speed = 0.02;
	map->text_width = 64;
	map->text_height = 64;
	map->nbr_sprites = 0;
	map->sprite = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xb0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xb8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rax)
movq -0x8(%rbp), %rdi
callq 0xccf0
movq -0x8(%rbp), %rax
movsd 0x4d83(%rip), %xmm0     # 0x11bf0
movsd %xmm0, 0xc8(%rax)
movq -0x8(%rbp), %rax
movsd 0x4d67(%rip), %xmm0     # 0x11be8
movsd %xmm0, 0xd0(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x178(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x158(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)