LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1080
callq 0x10b0
movslq %eax, %rdi
imulq $-0x7fff7fff, %rdi, %rax # imm = 0x80008001
shrq $0x20, %rax
addl %eax, %edi
movl %edi, %eax
shrl $0x1f, %eax
sarl $0xf, %edi
addl %eax, %edi
callq 0x146d
movq %rax, %r12
leal 0x2(%rax), %edi
callq 0x146d
movq %rax, %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r12d, %ecx
addl %eax, %ecx
movl %ebp, %r15d
addl %eax, %r15d
imull %ecx, %r15d
movl $0x1, %r14d
incq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1454
cmpq $0x1, %rax
jne 0x1224
movl %ebp, %r13d
imull %r12d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x148e
movsd %xmm0, (%rsp)
leaq 0xdae(%rip), %rdi       # 0x2004
movl %r12d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1060
leaq 0xdb8(%rip), %rdi       # 0x2021
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1060
leaq 0xdc5(%rip), %rdi       # 0x2042
movq %r14, %rsi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x1060
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
xorl %esi, %esi
ucomisd (%rsp), %xmm0
seta %sil
leaq 0xdbc(%rip), %rdi       # 0x2062
xorl %eax, %eax
callq 0x1060
movq %r14, (%rbx)
cvttsd2si (%rsp), %rax
movq %r13, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x131c
movq %r8, %rbx
testq %r8, %r8
je 0x1318
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
xorl %r13d, %r13d
movsbq (%r12,%r13), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x14e7
movq %rax, (%rbp,%r13,8)
incq %r13
cmpq %r13, %rbx
jne 0x12fb
xorl %eax, %eax
jmp 0x132d
leaq 0xd4b(%rip), %rdi       # 0x206e
callq 0x1040
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1389
movq %r8, %rbx
testq %r8, %r8
je 0x1385
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
xorl %r13d, %r13d
movb $0x0, (%rbp,%r13)
movq (%r12,%r13,8), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x14e7
movb %al, (%rbp,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x1363
xorl %eax, %eax
jmp 0x139a
leaq 0xcde(%rip), %rdi       # 0x206e
callq 0x1040
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x2, %rdi
jge 0x13b5
xorl %eax, %eax
retq
movl $0x1, %eax
cmpq $0x4, %rdi
jl 0x1453
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rdi, %rax
mulq %rcx
testb $0x1, %dil
je 0x13b2
shrq %rdx
leaq (%rdx,%rdx,2), %rcx
movq %rdi, %rdx
movl $0x0, %eax
subq %rcx, %rdx
je 0x1453
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %rcx
cmpq $0x19, %rdi
setl %cl
jl 0x144d
shrq $0x2, %rdx
leaq (%rdx,%rdx,4), %rax
movq %rdi, %rdx
subq %rax, %rdx
je 0x144d
movl $0xb, %esi
leaq -0x4(%rsi), %r8
movq %rdi, %rax
xorl %edx, %edx
divq %r8
testq %rdx, %rdx
je 0x144d
movq %rsi, %rax
imulq %rsi, %rax
cmpq %rdi, %rax
setg %cl
jg 0x144d
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
addq $0x6, %rsi
testq %rdx, %rdx
jne 0x141c
movzbl %cl, %eax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorpd %xmm0, %xmm0
cmpq $0x1, %rsi
je 0x14e6
movq %rdi, %rax
movl $0x1, %edi
cmpq $0x2, %rax
jb 0x14d6
xorl %r9d, %r9d
movl $0x1, %r8d
movq %rsi, %r10
xorl %edx, %edx
divq %r10
movq %rax, %rcx
movl %r9d, %edi
movslq %r10d, %rax
imull %r9d, %ecx
movl %r8d, %r9d
subl %ecx, %r9d
movl %edi, %r8d
movq %rdx, %r10
cmpq $0x1, %rax
ja 0x14b2
movl %edi, %eax
sarl $0x1f, %eax
andl %esi, %eax
addl %edi, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
testq %rdx, %rdx
js 0x15c7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0xf9f, %rdx            # imm = 0xF9F
jg 0x157e
movq (%r14,%rbx,8), %rax
testq %rax, %rax
jne 0x15b9
cmpq $0x1, %rbx
je 0x15c8
testq %rbx, %rbx
jne 0x15d0
movq $0x1, (%r14,%rbx,8)
movl $0x1, %eax
jmp 0x15b9
movq %rbx, %r12
shrq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x152e
movq %rax, %r13
subq %r12, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x152e
imulq %r13, %rax
movslq %ebp, %rcx
cqto
idivq %rcx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %rcx
movq %r15, %rax
jmp 0x1603
movq %rbx, %r12
shrq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x152e
movq %rax, %r13
movq %rbx, %rdx
subq %r12, %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x152e
imulq %r13, %rax
movslq %ebp, %rcx
cqto
idivq %rcx
movq %rdx, %rax
movq %rdx, (%r14,%rbx,8)
jmp 0x15b9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/dubeyalok7[P]crypto-algo/rsa/main.c
// Function: main
int main(int argc, char *argv[])
{
  long long emsg[MSG_LIMIT]={0};
  unsigned char dmsg[MSG_LIMIT] = {0};
  char msg[MSG_LIMIT]={'\0'};
  int i;
  size_t len;
  if((argc<=1)||(argc>2)){
    printf("rsa help:\n\
        ./rsa <message>\n");
    return 0;
  }
  len = strlen(argv[1]);
  if(len>=MSG_LIMIT){
    printf("Error: enter msg within limits of 1-1022");
    return 0;
  }
  memcpy(msg, argv[1], len);

  printf("Input msg: ");
  for(i=0; i<len;i++)
      printf("%x ",msg[i]);
  printf("\n");

  struct keygen_t key = keygen();
  encrypt(emsg, msg, key.pub ,len);
  printf("Cipher :\n");
  for(i=0; i<len;i++)
      printf("%llx ",emsg[i]);
  printf("\n");

  decrypt(dmsg, emsg, key.pri, len);
  printf("Decipher :\n");
  for(i=0; i<len;i++)
      printf("%x ",dmsg[i]);
  printf("\n");;

  printf("original msg: %s\n", msg);
  printf("decrypt  msg: %s\n", dmsg);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2828, %rsp           # imm = 0x2828
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x820(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x1070
leaq 0x420(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x1070
leaq 0x20(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x1070
cmpl $0x2, %ebp
jne 0x168b
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x1050
cmpq $0x400, %rax            # imm = 0x400
jb 0x169c
leaq 0xa09(%rip), %rdi       # 0x2088
xorl %eax, %eax
callq 0x1060
jmp 0x17df
leaq 0xa6d(%rip), %rdi       # 0x20ff
callq 0x1040
jmp 0x17df
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1090
leaq 0x9fb(%rip), %rdi       # 0x20b1
xorl %eax, %eax
callq 0x1060
testq %rbx, %rbx
je 0x16e4
leaq 0x9f4(%rip), %r14       # 0x20bd
xorl %r15d, %r15d
movsbl 0x20(%rsp,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
incq %r15
cmpq %r15, %rbx
jne 0x16cc
movl $0xa, %edi
callq 0x1030
movq %rsp, %r14
movq %r14, %rdi
callq 0x11bc
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x820(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %r8
callq 0x12d4
leaq 0x9cf(%rip), %rdi       # 0x20eb
callq 0x1040
testq %rbx, %rbx
je 0x174a
leaq 0x994(%rip), %r14       # 0x20c1
xorl %r15d, %r15d
movq 0x820(%rsp,%r15,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
incq %r15
cmpq %r15, %rbx
jne 0x1730
movl $0xa, %edi
callq 0x1030
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x420(%rsp), %rdi
leaq 0x820(%rsp), %rsi
movq %rbx, %r8
callq 0x133c
leaq 0x977(%rip), %rdi       # 0x20f4
callq 0x1040
testq %rbx, %rbx
je 0x17ac
leaq 0x92f(%rip), %r14       # 0x20bd
xorl %r15d, %r15d
movzbl 0x420(%rsp,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
incq %r15
cmpq %r15, %rbx
jne 0x1791
movl $0xa, %edi
callq 0x1030
leaq 0x90a(%rip), %rdi       # 0x20c7
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0x1060
leaq 0x909(%rip), %rdi       # 0x20d9
leaq 0x420(%rsp), %rsi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x2828, %rsp           # imm = 0x2828
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x4658
movq %rax, %rbx
leaq 0x1525(%rip), %rsi      # 0x5318
movq %rax, %rdi
callq 0x4729
leaq 0x151a(%rip), %rsi      # 0x531c
movq %rbx, %rdi
callq 0x4729
leaq 0x150f(%rip), %rdi      # 0x5320
movq %rbx, %rsi
callq 0x4618
xorl %edi, %edi
testl %eax, %eax
setg %dil
leaq 0x1506(%rip), %rsi      # 0x532e
leaq 0x168d(%rip), %rcx      # 0x54bc
leaq 0x1502(%rip), %r8       # 0x5338
movl $0x13, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3e4f
movq %rbx, %rdi
popq %rbx
jmp 0x4842
callq 0x2e43
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x14c4(%rip), %rdi      # 0x5320
callq 0x4575
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
leaq 0x14ba(%rip), %rsi      # 0x532e
leaq 0x1641(%rip), %rcx      # 0x54bc
leaq 0x14e8(%rip), %r8       # 0x536a
movl $0x1a, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f78
movq %rbx, %rdi
xorl %esi, %esi
callq 0x469c
leaq 0x1471(%rip), %rsi      # 0x5318
movq %rax, %rdi
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1470(%rip), %rsi      # 0x532e
leaq 0x15f7(%rip), %rcx      # 0x54bc
leaq 0x14aa(%rip), %r8       # 0x5376
movl $0x1c, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f78
movq %rbx, %rdi
movl $0x1, %esi
callq 0x469c
leaq 0x1428(%rip), %rsi      # 0x531c
movq %rax, %rdi
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1423(%rip), %rsi      # 0x532e
leaq 0x15aa(%rip), %rcx      # 0x54bc
leaq 0x1487(%rip), %r8       # 0x53a0
movl $0x1d, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f78
leaq 0x13f0(%rip), %rdi      # 0x5320
callq 0x2070
leaq 0x148e(%rip), %rdi      # 0x53ca
callq 0x4575
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0x13dd(%rip), %rsi      # 0x532e
leaq 0x1564(%rip), %rcx      # 0x54bc
leaq 0x1484(%rip), %r8       # 0x53e3
movl $0x22, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f78
movq %rbx, %rdi
popq %rbx
jmp 0x4842
callq 0x2e43
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl $0x1, %esi
xorl %edx, %edx
callq 0x4dfa
cvttsd2si %xmm0, %ecx
leaq 0x1b845(%rip), %rdx     # 0x20004
leaq -0x410(%rbp), %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4180
movq %rbx, %rdi
callq 0x4150
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
callq 0x1403e
movq %rax, %rbx
movq %rax, %rdi
callq 0x14240
leaq 0x1b80b(%rip), %rsi     # 0x20012
movq %rbx, %rdi
xorl %edx, %edx
callq 0x137b1
testl %eax, %eax
jne 0x482c
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5b02
leaq 0x1b7ec(%rip), %r14     # 0x2001f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x563f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x49c9
leaq -0xb3(%rip), %rsi       # 0x479c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5209
leaq 0x1b7c7(%rip), %rsi     # 0x20027
movq %rbx, %rdi
callq 0x563f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52d8
leaq 0x1b7b7(%rip), %rdx     # 0x20031
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x53ef
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5a9a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_error5.c
// Function: ft_error5
void	ft_error5(int err)
{
	if (err == 48)
		ft_putstr("Error\nmlx_init n'a pas fonctionné fichier ft_cub3d\n");
	if (err == 49)
		ft_putstr("Error\nL'init d'une image a échoué fichier init_texture\n");
	if (err == 50)
		ft_putstr("Error\nmlx_new_window a échoué fichier ft_cub3d.h\n");
	if (err == 51)
	{
		ft_putstr("Error\nl'init de l'image de la fenêtre a échoué ");
		ft_putstr("fichier next_frame\n");
	}
	if (err == 52)
		ft_putstr("Error\n malloc de ft_list_push_front a échoué\n");
	if (err == 53)
		ft_putstr("Error\n le fichier n'a pas pus etre créé\n");
	if (err == 54)
		ft_putstr("Error\n le fichier n'a pas était bien fermé\n");
}

// Assembly:
addl $-0x30, %edi
cmpl $0x6, %edi
ja 0x8c15
leaq 0x6bad(%rip), %rax      # 0xf778
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x6bb9(%rip), %rdi      # 0xf794
jmp 0x9954
leaq 0x6c97(%rip), %rdi      # 0xf87e
jmp 0x9954
leaq 0x6c10(%rip), %rdi      # 0xf803
jmp 0x9954
pushq %rax
leaq 0x6c37(%rip), %rdi      # 0xf837
callq 0x9954
leaq 0x6c5e(%rip), %rdi      # 0xf86a
addq $0x8, %rsp
jmp 0x9954
retq
leaq 0x6bac(%rip), %rdi      # 0xf7c9
jmp 0x9954
leaq 0x6c85(%rip), %rdi      # 0xf8ae
jmp 0x9954
leaq 0x6ca4(%rip), %rdi      # 0xf8d9
jmp 0x9954
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_exit.c
// Function: ft_exit
int	ft_exit(t_map *map)
{
	free_img_text(map);
	ft_sprite_clear(map->sprite);
	if (map->argc != 3)
		mlx_destroy_window(map->mlx.mlx, map->mlx.win);
	mlx_destroy_display(map->mlx.mlx);
	free(map->mlx.mlx);
	ft_check_malloc(map);
	exit(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x76e5
movq 0x158(%rbx), %rdi
callq 0xaa0c
cmpl $0x3, 0x17c(%rbx)
je 0x8c91
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
callq 0xe840
movq 0x80(%rbx), %rdi
callq 0xeee0
movq 0x80(%rbx), %rdi
callq 0x7180
movq %rbx, %rdi
callq 0x7c8a
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_finnish_check_split.c
// Function: ft_finnish_check_split
int	ft_finnish_check_split(t_map *map)
{
	if (map->first_map == NULL || map->orientation == '0' || map->res_x == 0 ||
		map->res_y == 0 || map->north_text == NULL || map->south_text == NULL ||
		map->west_text == NULL || map->east_text == NULL ||
		map->sprite_text == NULL || map->c_color == -1 || map->f_color == -1)
		return (ft_error4(45) + 1);
	if ((map->map = ft_split2(map, '\n')) == NULL)
		return (ft_error4(46) + 1);
	if (ft_check_map2(map->map) == 1)
		return (ft_error4(47) + 1);
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2d, %edi
cmpq $0x0, 0x8(%rbx)
je 0x8d3b
cmpb $0x30, 0x10(%rbx)
je 0x8d3b
cmpl $0x0, 0x18(%rbx)
je 0x8d3b
cmpl $0x0, 0x1c(%rbx)
je 0x8d3b
cmpq $0x0, 0x50(%rbx)
je 0x8d3b
cmpq $0x0, 0x58(%rbx)
je 0x8d3b
cmpq $0x0, 0x60(%rbx)
je 0x8d3b
cmpq $0x0, 0x68(%rbx)
je 0x8d3b
cmpq $0x0, 0x70(%rbx)
je 0x8d3b
cmpl $-0x1, 0x78(%rbx)
je 0x8d3b
cmpl $-0x1, 0x7c(%rbx)
je 0x8d3b
movq %rbx, %rdi
movl $0xa, %esi
callq 0xa888
movq %rax, (%rbx)
testq %rax, %rax
je 0x8d36
movq %rax, %rdi
callq 0x7d82
movl %eax, %ecx
xorl %eax, %eax
movl $0x2f, %edi
cmpl $0x1, %ecx
je 0x8d3b
jmp 0x8d42
movl $0x2e, %edi
callq 0x8b94
incl %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_free2.c
// Function: ft_free2
char	*ft_free2(char **tab, int max)
{
	int	i;

	i = -1;
	while (tab != NULL && tab[++i] != NULL && i < max)
	{
		if (tab[i] != NULL)
		{
			free(tab[i]);
			tab[i] = NULL;
		}
	}
	free(tab);
	tab = NULL;
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x8d7a
movslq %esi, %r14
xorl %r15d, %r15d
cmpq %r14, %r15
jge 0x8d7a
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x8d7a
callq 0x7180
movq $0x0, (%rbx,%r15,8)
incq %r15
testq %rbx, %rbx
jne 0x8d57
movq %rbx, %rdi
callq 0x7180
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_global_save.c
// Function: ft_global_save
void	ft_global_save(t_map *map)
{
	next_frame(map);
	ft_save(map);
	free_img_text(map);
	ft_sprite_clear(map->sprite);
	mlx_destroy_image(map->mlx.mlx, map->mlx.img);
	mlx_destroy_display(map->mlx.mlx);
	free(map->mlx.mlx);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xb850
movq %rbx, %rdi
callq 0xa7b0
movq %rbx, %rdi
callq 0x76e5
movq 0x158(%rbx), %rdi
callq 0xaa0c
movq 0x80(%rbx), %rdi
movq 0x90(%rbx), %rsi
callq 0xedf0
movq 0x80(%rbx), %rdi
callq 0xeee0
movq 0x80(%rbx), %rdi
popq %rbx
jmp 0x7180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_init_ptr.c
// Function: ft_init_ptr
void	ft_init_ptr(int (**ptr)(t_map *map, char *line, int i))
{
	ptr[0] = ft_recup_resolution;
	ptr[1] = ft_recup_text_north;
	ptr[2] = ft_recup_text_south;
	ptr[3] = ft_recup_text_west;
	ptr[4] = ft_recup_text_east;
	ptr[5] = ft_recup_text_sprite;
	ptr[6] = ft_recup_f_color;
	ptr[7] = ft_recup_c_color;
	ptr[8] = ft_recup_line_map;
}

// Assembly:
leaq 0x1251(%rip), %rax      # 0xa04c
movq %rax, (%rdi)
leaq 0x147b(%rip), %rax      # 0xa280
movq %rax, 0x8(%rdi)
leaq 0x1578(%rip), %rax      # 0xa388
movq %rax, 0x10(%rdi)
leaq 0x1775(%rip), %rax      # 0xa590
movq %rax, 0x18(%rdi)
leaq 0x1356(%rip), %rax      # 0xa17c
movq %rax, 0x20(%rdi)
leaq 0x165b(%rip), %rax      # 0xa48c
movq %rax, 0x28(%rdi)
leaq 0xf88(%rip), %rax       # 0x9dc4
movq %rax, 0x30(%rdi)
leaq 0xcdd(%rip), %rax       # 0x9b24
movq %rax, 0x38(%rdi)
leaq 0x1122(%rip), %rax      # 0x9f74
movq %rax, 0x40(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_list_push_front.c
// Function: ft_list_push_front
int	ft_list_push_front(t_sprite **sprite, int x, int y)
{
	t_sprite	*new_elem;

	new_elem = NULL;
	new_elem = ft_create_elem(x, y);
	if (new_elem == NULL)
		return (-1);
	new_elem->next = *sprite;
	*sprite = new_elem;
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movl %edx, %esi
callq 0x8197
testq %rax, %rax
je 0x8e78
movq (%rbx), %rcx
movq %rcx, 0x68(%rax)
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x8e7d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_modif_atoi.c
// Function: ft_modif_atoi
int	ft_modif_atoi(char *str)
{
	int	i;
	int	num;

	num = 0;
	i = -1;
	while (str[++i] == ' ')
		;
	--i;
	while (str[++i] > 47 && str[i] < 58)
	{
		num *= 10;
		num += (str[i] - 48);
		if (num * 10 > 2147483647)
			return (num);
	}
	return (num);
}

// Assembly:
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rdx      # imm = 0x100000000
movq %rdi, %rcx
addq %rdx, %rax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0x8e97
sarq $0x20, %rax
movb (%rdi,%rax), %dl
leal -0x30(%rdx), %esi
xorl %eax, %eax
cmpb $0x9, %sil
ja 0x8ed1
xorl %eax, %eax
leal (%rax,%rax,4), %eax
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rax,2), %eax
movb (%rcx), %dl
leal -0x30(%rdx), %esi
incq %rcx
cmpb $0xa, %sil
jb 0x8eb7
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_modif_strcpy.c
// Function: ft_modif_strcpy
char	*ft_modif_strcpy(char *str)
{
	int		i;
	char	*str2;

	i = -1;
	while (str[++i] && str[i] != ' ')
		;
	if ((str2 = malloc(sizeof(char) * (i + 1))) == NULL)
		return (NULL);
	i = -1;
	while (str[++i] && str[i] != ' ')
		str2[i] = str[i];
	str2[i] = '\0';
	return (str2);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rbx, %rcx
addq %rax, %rdi
movzbl (%rcx), %edx
incq %rcx
testb $-0x21, %dl
jne 0x8ee7
sarq $0x20, %rdi
callq 0x7100
testq %rax, %rax
je 0x8f1c
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %edx
testb $-0x21, %dl
je 0x8f16
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x8f05
movb $0x0, (%rax,%rcx)
jmp 0x8f1e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_modif_strdup.c
// Function: ft_modif_strdup
char	*ft_modif_strdup(char *str)
{
	char	*str2;
	int		i;

	i = -1;
	str2 = NULL;
	while (str[++i])
		;
	if ((str2 = malloc(sizeof(char) * (i + 2))) == NULL)
		return (NULL);
	i = -1;
	while (str[++i])
		str2[i] = (str[i] == ' ') ? 49 : str[i];
	str2[i] = '\n';
	str2[++i] = '\0';
	return (str2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000000, %r14      # imm = 0x100000000
movq %rdi, %rax
movq %r14, %rdi
addq %r14, %rdi
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x8f37
sarq $0x20, %rdi
callq 0x7100
testq %rax, %rax
je 0x8f8a
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
xorl %edx, %edx
movzbl (%rbx,%rdx), %esi
movb $0x31, %dil
cmpl $0x20, %esi
je 0x8f6f
testl %esi, %esi
je 0x8f7b
movl %esi, %edi
movb %dil, (%rax,%rdx)
addq %r14, %rcx
incq %rdx
jmp 0x8f5d
movb $0xa, (%rax,%rdx)
sarq $0x20, %rcx
movb $0x0, 0x2(%rax,%rcx)
jmp 0x8f8c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_move2.c
// Function: ft_move2
void	ft_move2(t_map *map)
{
	if (map->key.key_s == 1)
	{
		if (map->map[(int)map->player.pos_y][(int)(map->player.pos_x -
		map->player.dir_y * map->player.move_speed)] == '0')
			map->player.pos_x -= map->player.dir_y * map->player.move_speed;
		if (map->map[(int)(map->player.pos_y + map->player.dir_x *
		map->player.move_speed)][(int)map->player.pos_x] == '0')
			map->player.pos_y += map->player.dir_x * map->player.move_speed;
	}
	if (map->key.key_d == 1)
	{
		if (map->map[(int)map->player.pos_y][(int)(map->player.pos_x +
		map->player.dir_y * map->player.move_speed)] == '0')
			map->player.pos_x += map->player.dir_y * map->player.move_speed;
		if (map->map[(int)(map->player.pos_y - map->player.dir_x *
		map->player.move_speed)][(int)map->player.pos_x] == '0')
			map->player.pos_y -= map->player.dir_x * map->player.move_speed;
	}
	ft_move3(map);
}

// Assembly:
cmpl $0x1, 0x148(%rdi)
jne 0x9018
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm3
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x8fe8
movsd %xmm2, 0x98(%rdi)
mulsd 0xa8(%rdi), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
cvttsd2si 0x98(%rdi), %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x9018
movsd %xmm0, 0xa0(%rdi)
cmpl $0x1, 0x14c(%rdi)
jne 0x90a8
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm0
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movsd 0xc8(%rdi), %xmm1
movsd 0xb0(%rdi), %xmm2
mulsd %xmm1, %xmm2
addsd 0x98(%rdi), %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x906c
movsd %xmm2, 0x98(%rdi)
mulsd 0xa8(%rdi), %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
cvttsd2si 0x98(%rdi), %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x90a8
movsd %xmm0, 0xa0(%rdi)
jmp 0x90a8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_move3.c
// Function: ft_move3
void	ft_move3(t_map *map)
{
	double	old_dir_x;
	double	old_plane_x;

	if (map->key.key_right == 1)
	{
		old_dir_x = map->player.dir_x;
		map->player.dir_x = map->player.dir_x * cos(-map->player.rotate_speed) -
		map->player.dir_y * sin(-map->player.rotate_speed);
		map->player.dir_y = old_dir_x * sin(-map->player.rotate_speed) +
		map->player.dir_y * cos(-map->player.rotate_speed);
		old_plane_x = map->player.plane_x;
		map->player.plane_x = map->player.plane_x *
		cos(-map->player.rotate_speed) - map->player.plane_y *
		sin(-map->player.rotate_speed);
		map->player.plane_y = old_plane_x * sin(-map->player.rotate_speed) +
		map->player.plane_y * cos(-map->player.rotate_speed);
	}
	ft_move4(map);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x150(%rdi)
jne 0x9209
movsd 0xa8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xa8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xb0(%rbx)
movsd 0xb8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xb8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xc0(%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x9218
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_move4.c
// Function: ft_move4
void	ft_move4(t_map *map)
{
	double	old_dir_x;
	double	old_plane_x;

	if (map->key.key_left == 1)
	{
		old_dir_x = map->player.dir_x;
		map->player.dir_x = map->player.dir_x * cos(map->player.rotate_speed) -
		map->player.dir_y * sin(map->player.rotate_speed);
		map->player.dir_y = old_dir_x * sin(map->player.rotate_speed) +
		map->player.dir_y * cos(map->player.rotate_speed);
		old_plane_x = map->player.plane_x;
		map->player.plane_x = map->player.plane_x *
		cos(map->player.rotate_speed) - map->player.plane_y *
		sin(map->player.rotate_speed);
		map->player.plane_y = old_plane_x * sin(map->player.rotate_speed) +
		map->player.plane_y * cos(map->player.rotate_speed);
	}
}

// Assembly:
cmpl $0x1, 0x154(%rdi)
jne 0x937e
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0xa8(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rdi), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0xa8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xb0(%rbx)
movsd 0xb8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0xb8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7430
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xc0(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_move.c
// Function: ft_move
void	ft_move(t_map *map)
{
	if (map->key.key_a == 1)
	{
		if (map->map[(int)(map->player.pos_y + (map->player.dir_y *
		map->player.move_speed) * 6)][(int)(map->player.pos_x)] == '0')
			map->player.pos_y += map->player.dir_y * map->player.move_speed;
		if (map->map[(int)(map->player.pos_y)][(int)(map->player.pos_x +
		(map->player.dir_x * map->player.move_speed) * 6)] == '0')
			map->player.pos_x += map->player.dir_x * map->player.move_speed;
	}
	if (map->key.key_w == 1)
	{
		if (map->map[(int)(map->player.pos_y - map->player.dir_y *
		map->player.move_speed)][(int)map->player.pos_x] == '0')
			map->player.pos_y -= map->player.dir_y * map->player.move_speed;
		if (map->map[(int)map->player.pos_y][(int)(map->player.pos_x -
		map->player.dir_x * map->player.move_speed)] == '0')
			map->player.pos_x -= map->player.dir_x * map->player.move_speed;
	}
	ft_move2(map);
}

// Assembly:
cmpl $0x1, 0x140(%rdi)
jne 0x9428
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm3
mulsd %xmm0, %xmm3
movsd 0x67cc(%rip), %xmm1     # 0xfb80
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x93e8
addsd %xmm2, %xmm3
movsd %xmm3, 0xa0(%rdi)
cvttsd2si 0xa0(%rdi), %ecx
movslq %ecx, %rcx
mulsd 0xa8(%rdi), %xmm0
movsd 0x677d(%rip), %xmm2     # 0xfb80
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x9428
addsd %xmm1, %xmm0
movsd %xmm0, 0x98(%rdi)
cmpl $0x1, 0x144(%rdi)
jne 0x8f94
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x9480
movsd %xmm2, 0xa0(%rdi)
cvttsd2si 0xa0(%rdi), %ecx
mulsd 0xa8(%rdi), %xmm0
movslq %ecx, %rcx
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x8f94
movsd %xmm1, 0x98(%rdi)
jmp 0x8f94
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_point2.c
// Function: ft_point2
void	ft_point2(t_map *map)
{
	if (map->ray.ray_dir_x < 0)
	{
		map->point.step_x = -1;
		map->point.side_dist_x = (map->player.pos_x - map->point.map_x) *
		map->point.delta_dist_x;
	}
	else
	{
		map->point.step_x = 1;
		map->point.side_dist_x = (map->point.map_x + 1.0 - map->player.pos_x) *
		map->point.delta_dist_x;
	}
	if (map->ray.ray_dir_y < 0)
	{
		map->point.step_y = -1;
		map->point.side_dist_y = (map->player.pos_y - map->point.map_y) *
		map->point.delta_dist_y;
	}
	else
	{
		map->point.step_y = 1;
		map->point.side_dist_y = (map->point.map_y + 1.0 - map->player.pos_y) *
		map->point.delta_dist_y;
	}
}

// Assembly:
xorpd %xmm0, %xmm0
ucomisd 0xe0(%rdi), %xmm0
jbe 0x94ea
movl $0xffffffff, 0x120(%rdi) # imm = 0xFFFFFFFF
movsd 0x98(%rdi), %xmm0
cvtsi2sdl 0xf0(%rdi), %xmm1
subsd %xmm1, %xmm0
jmp 0x950f
movl $0x1, 0x120(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0xf0(%rdi), %xmm0
addsd 0x6681(%rip), %xmm0     # 0xfb88
subsd 0x98(%rdi), %xmm0
mulsd 0x108(%rdi), %xmm0
movsd %xmm0, 0xf8(%rdi)
xorpd %xmm0, %xmm0
ucomisd 0xe8(%rdi), %xmm0
jbe 0x9550
movl $0xffffffff, 0x124(%rdi) # imm = 0xFFFFFFFF
movsd 0xa0(%rdi), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0xf4(%rdi), %xmm1
subsd %xmm1, %xmm0
jmp 0x9575
movl $0x1, 0x124(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0xf4(%rdi), %xmm0
addsd 0x661b(%rip), %xmm0     # 0xfb88
subsd 0xa0(%rdi), %xmm0
mulsd 0x110(%rdi), %xmm0
movsd %xmm0, 0x100(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_point.c
// Function: ft_point
void	ft_point(t_map *map, int x)
{
	map->ray.camera_x = (2 * x) / (double)map->res_y - 1;
	map->ray.ray_dir_x = map->player.dir_x + map->player.plane_x *
	map->ray.camera_x;
	map->ray.ray_dir_y = map->player.dir_y + map->player.plane_y *
	map->ray.camera_x;
	map->point.map_x = (int)map->player.pos_x;
	map->point.map_y = (int)map->player.pos_y;
	if (map->ray.ray_dir_y == 0)
		map->point.delta_dist_x = 0;
	else
		map->point.delta_dist_x = (map->ray.ray_dir_x == 0) ? 1 : sqrt(1 +
		(map->ray.ray_dir_y * map->ray.ray_dir_y) / (map->ray.ray_dir_x *
		map->ray.ray_dir_x));
	if (map->ray.ray_dir_x == 0)
		map->point.delta_dist_y = 0;
	else
		map->point.delta_dist_y = (map->ray.ray_dir_y == 0) ? 1 : sqrt(1 +
		(map->ray.ray_dir_x * map->ray.ray_dir_x) / (map->ray.ray_dir_y *
		map->ray.ray_dir_y));
	map->point.hit = 0;
	ft_point2(map);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addl %esi, %esi
cvtsi2sd %esi, %xmm0
cvtsi2sdl 0x1c(%rdi), %xmm1
divsd %xmm1, %xmm0
addsd 0x65ed(%rip), %xmm0     # 0xfb90
movsd %xmm0, 0xd8(%rdi)
movsd 0xb8(%rdi), %xmm2
mulsd %xmm0, %xmm2
addsd 0xa8(%rdi), %xmm2
movsd %xmm2, 0xe0(%rdi)
mulsd 0xc0(%rdi), %xmm0
addsd 0xb0(%rdi), %xmm0
movsd %xmm0, 0xe8(%rdi)
cvttsd2si 0x98(%rdi), %eax
movl %eax, 0xf0(%rdi)
cvttsd2si 0xa0(%rdi), %eax
movl %eax, 0xf4(%rdi)
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
xorpd %xmm1, %xmm1
jne 0x960b
jnp 0x964d
ucomisd %xmm1, %xmm2
jne 0x961d
jp 0x961d
movsd 0x656d(%rip), %xmm1     # 0xfb88
jmp 0x964d
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm0
addsd 0x6557(%rip), %xmm0     # 0xfb88
ucomisd %xmm1, %xmm0
jb 0x9640
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0x964d
callq 0x73f0
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm1
movsd %xmm1, 0x108(%rbx)
movsd 0xe0(%rbx), %xmm0
ucomisd %xmm3, %xmm0
jne 0x9665
jnp 0x96af
movsd 0xe8(%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x9683
jp 0x9683
movsd 0x6507(%rip), %xmm3     # 0xfb88
jmp 0x96af
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm0
addsd 0x64f1(%rip), %xmm0     # 0xfb88
ucomisd %xmm1, %xmm0
jb 0x96a6
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x96af
callq 0x73f0
movapd %xmm0, %xmm3
movsd %xmm3, 0x110(%rbx)
movl $0x0, 0x128(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x94bc
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_point_sprite2.c
// Function: ft_point_sprite2
void	ft_point_sprite2(t_sprite *sprite, t_map *map)
{
	sprite->sprite_width = (int)(map->res_x / (sprite->transform_y));
	sprite->sprite_width *= (sprite->sprite_width < 0) ? -1 : 1;
	sprite->draw_start_x = -sprite->sprite_width / 2 + sprite->sprite_screen_x;
	sprite->draw_start_x *= (sprite->draw_start_x < 0) ? 0 : 1;
	sprite->draw_end_x = sprite->sprite_width / 2 + sprite->sprite_screen_x;
	if (sprite->draw_end_x >= map->res_x)
		sprite->draw_end_x = map->res_x - 1;
}

// Assembly:
movl 0x18(%rsi), %eax
cvtsi2sd %eax, %xmm0
divsd 0x38(%rdi), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
movl %edx, 0x50(%rdi)
shrl %edx
movl 0x40(%rdi), %ecx
movl %ecx, %esi
subl %edx, %esi
xorl %r8d, %r8d
testl %esi, %esi
cmovgl %esi, %r8d
movl %r8d, 0x54(%rdi)
addl %ecx, %edx
leal -0x1(%rax), %ecx
cmpl %eax, %edx
cmovll %edx, %ecx
movl %ecx, 0x58(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_point_sprite.c
// Function: ft_point_sprite
void	ft_point_sprite(t_sprite *sprite, t_map *map)
{
	sprite->sprite_x = sprite->pos_x - map->player.pos_x;
	sprite->sprite_y = sprite->pos_y - map->player.pos_y;
	sprite->inv_det = 1.0 / (map->player.plane_x * map->player.dir_y -
	map->player.dir_x * map->player.plane_y);
	sprite->transform_x = sprite->inv_det * (map->player.dir_y *
	sprite->sprite_x - map->player.dir_x * sprite->sprite_y);
	sprite->transform_y = sprite->inv_det * (-map->player.plane_y *
	sprite->sprite_x + map->player.plane_x * sprite->sprite_y);
	sprite->sprite_screen_x = (int)((map->res_y / 2) * (1 + sprite->transform_x
	/ sprite->transform_y));
	sprite->sprite_height = (map->res_x >= map->res_y) ? (int)(map->res_x /
	(sprite->transform_y)) : (int)(map->res_y / (sprite->transform_y));
	sprite->sprite_height *= (sprite->sprite_height < 0) ? -1 : 1;
	sprite->draw_start_y = -sprite->sprite_height / 2 + map->res_y / 2;
	sprite->draw_start_y *= (sprite->draw_start_y < 0) ? 0 : 1;
	sprite->draw_end_y = sprite->sprite_height / 2 + map->res_y / 2;
	if (sprite->draw_end_y >= map->res_y)
		sprite->draw_end_y = map->res_y - 1;
	ft_point_sprite2(sprite, map);
}

// Assembly:
movsd 0x8(%rdi), %xmm2
subsd 0x98(%rsi), %xmm2
movsd 0x10(%rdi), %xmm0
movsd %xmm2, 0x18(%rdi)
subsd 0xa0(%rsi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0xb8(%rsi), %xmm3
movsd 0xa8(%rsi), %xmm4
movsd 0xb0(%rsi), %xmm1
movsd 0xc0(%rsi), %xmm5
movapd %xmm3, %xmm6
mulsd %xmm1, %xmm6
mulsd %xmm2, %xmm1
mulsd %xmm5, %xmm2
mulsd %xmm4, %xmm5
subsd %xmm5, %xmm6
movsd 0x6418(%rip), %xmm5     # 0xfb88
movapd %xmm5, %xmm7
divsd %xmm6, %xmm7
movsd %xmm7, 0x28(%rdi)
mulsd %xmm0, %xmm4
subsd %xmm4, %xmm1
mulsd %xmm7, %xmm1
movsd %xmm1, 0x30(%rdi)
mulsd %xmm3, %xmm0
subsd %xmm2, %xmm0
mulsd %xmm7, %xmm0
movsd %xmm0, 0x38(%rdi)
movl 0x1c(%rsi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
divsd %xmm0, %xmm1
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %edx
movl %edx, 0x40(%rdi)
movl 0x18(%rsi), %edx
cmpl %eax, %edx
cmovlel %eax, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movl %r8d, 0x44(%rdi)
shrl %r8d
movl %ecx, %edx
subl %r8d, %edx
xorl %r9d, %r9d
testl %edx, %edx
cmovgl %edx, %r9d
addl %ecx, %r8d
leal -0x1(%rax), %ecx
cmpl %eax, %r8d
cmovll %r8d, %ecx
movl %r9d, 0x48(%rdi)
movl %ecx, 0x4c(%rdi)
jmp 0x96cc
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_point_wall2.c
// Function: ft_point_wall2
void	ft_point_wall2(t_map *map)
{
	double	wall_x;
	int		tex_x;

	if (map->point.side == 0)
		wall_x = map->player.pos_y + map->point.perp_wall_dist *
		map->ray.ray_dir_y;
	else
		wall_x = map->player.pos_x + map->point.perp_wall_dist *
		map->ray.ray_dir_x;
	wall_x -= floor((wall_x));
	tex_x = (int)(wall_x * (double)(map->text_width));
	if (map->point.side == 0 && map->ray.ray_dir_x > 0)
		tex_x = map->text_width - tex_x - 1;
	if (map->point.side == 1 && map->ray.ray_dir_y < 0)
		tex_x = map->text_width - tex_x - 1;
	map->point.tex_x = tex_x;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x12c(%rdi), %ebp
xorl %eax, %eax
testl %ebp, %ebp
sete %al
movsd 0x118(%rdi), %xmm0
mulsd 0xe0(%rdi,%rax,8), %xmm0
addsd 0x98(%rdi,%rax,8), %xmm0
movsd %xmm0, (%rsp)
callq 0x7380
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movl 0x20(%rbx), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
testl %ebp, %ebp
jne 0x9880
movsd 0xe0(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9880
notl %eax
addl %ecx, %eax
cmpl $0x1, %ebp
jne 0x9897
xorpd %xmm0, %xmm0
ucomisd 0xe8(%rbx), %xmm0
jbe 0x9897
notl %eax
addl %ecx, %eax
movl %eax, 0x130(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_point_wall.c
// Function: ft_point_wall
void	ft_point_wall(t_map *map)
{
	int	line_height;

	line_height = (int)(map->res_y / map->point.perp_wall_dist);
	map->draw.draw_start = -line_height / 2 + map->res_y / 2;
	if (map->draw.draw_start < 0)
		map->draw.draw_start = 0;
	map->draw.draw_end = line_height / 2 + map->res_y / 2;
	if (map->draw.draw_end >= map->res_y || map->draw.draw_end < 0)
		map->draw.draw_end = map->res_y - 1;
}

// Assembly:
movl 0x1c(%rdi), %eax
cvtsi2sd %eax, %xmm0
divsd 0x118(%rdi), %xmm0
cvttsd2si %xmm0, %ecx
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
movl %ecx, %esi
shrl $0x1f, %esi
addl %ecx, %esi
sarl %esi
movl %edx, %ecx
subl %esi, %ecx
xorl %r8d, %r8d
testl %ecx, %ecx
cmovgl %ecx, %r8d
movl %r8d, 0x138(%rdi)
addl %edx, %esi
leal -0x1(%rax), %ecx
testl %esi, %esi
movl %esi, %edx
cmovsl %ecx, %edx
cmpl %eax, %esi
cmovgel %ecx, %edx
movl %edx, 0x13c(%rdi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_put_in_tab.c
// Function: ft_put_in_tab
char	*ft_put_in_tab(char *str, char c)
{
	int		i;
	int		max;
	char	*str2;

	i = -1;
	while (str[++i] != c)
		;
	max = i;
	if ((str2 = malloc(sizeof(char) * (max + 1))) == NULL)
		return (NULL);
	i = -1;
	while (str[++i] != c)
		str2[i] = str[i];
	str2[i] = '\0';
	return (str2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %r14, %rcx
addq %rax, %rdi
leaq 0x1(%rcx), %rdx
cmpb %bl, (%rcx)
movq %rdx, %rcx
jne 0x9910
sarq $0x20, %rdi
callq 0x7100
testq %rax, %rax
je 0x9948
movb (%r14), %dl
xorl %ecx, %ecx
cmpb %bl, %dl
je 0x9942
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
jmp 0x9931
movb $0x0, (%rax,%rcx)
jmp 0x994a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_putstr.c
// Function: ft_putstr
void	ft_putstr(char *str)
{
	int	i;

	i = -1;
	if (str == NULL)
		return ;
	while (str[++i])
		write(1, &str[i], 1);
}

// Assembly:
testq %rdi, %rdi
je 0x997f
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x997e
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x73d0
cmpb $0x0, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
jne 0x9962
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_raycasting.c
// Function: ft_raycasting
void	ft_raycasting(t_map *map)
{
	int		x;
	double	z_buffer[map->res_x];

	x = -1;
	while (++x < map->res_x)
	{
		ft_point(map, x);
		ft_wall_hit(map);
		ft_distance(map);
		ft_point_wall(map);
		ft_point_wall2(map);
		ft_stock_data(map);
		ft_draw_wall(map, x, 0, 0);
		ft_draw_ceil_floor(map, x);
		z_buffer[x] = map->point.perp_wall_dist;
	}
	if (map->nbr_sprites > 0)
		ft_sprite(map, z_buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
movq %rsp, %r14
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
testl %eax, %eax
jle 0x9a13
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9588
movq %rbx, %rdi
callq 0xab98
movq %rbx, %rdi
callq 0x8565
movq %rbx, %rdi
callq 0x98a4
movq %rbx, %rdi
callq 0x9814
movq %rbx, %rdi
callq 0xaabc
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8a6d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8644
movsd 0x118(%rbx), %xmm0
movsd %xmm0, (%r14,%r15,8)
incq %r15
movslq 0x18(%rbx), %rax
cmpq %rax, %r15
jl 0x99ac
cmpl $0x0, 0x178(%rbx)
jle 0x9a27
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa930
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_c_color2.c
// Function: ft_recup_c_color2
int	ft_recup_c_color2(t_map *map, t_color color, char *line, int i)
{
	if (line[i] != '\0' && ft_free(line) == NULL)
		return (ft_error3(35) + 1);
	if ((color.t != 0 || color.r > 255 || color.g > 255 || color.b > 255) &&
		ft_free(line) == NULL)
		return (ft_error4(36) + 1);
	if ((color.t != 0 || color.r < 0 || color.g < 0 || color.b < 0) &&
		ft_free(line) == NULL)
		return (ft_error4(37) + 1);
	map->c_color = (color.t << 24 | color.r << 16 | color.g << 8 | color.b);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq %r8d, %rax
cmpb $0x0, (%rcx,%rax)
je 0x9a65
movq %r12, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9af6
movq %r15, %r13
shrq $0x20, %r13
movq %rbx, %rbp
shrq $0x20, %rbp
testl %r15d, %r15d
setne %al
movl $0x100, %ecx            # imm = 0x100
cmpl %ecx, %r13d
setge %dl
cmpl %ecx, %ebx
setge %sil
orb %dl, %sil
cmpl %ecx, %ebp
setge %cl
orb %al, %cl
orb %sil, %cl
cmpb $0x1, %cl
jne 0x9aa9
movq %r12, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9b02
testl %r15d, %r15d
setne %al
testq %r15, %r15
sets %cl
movabsq $-0x7fffffff80000000, %rdx # imm = 0x8000000080000000
testq %rdx, %rbx
setne %dl
orb %al, %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x9adb
movq %r12, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9b09
shll $0x18, %r15d
shll $0x10, %r13d
shll $0x8, %ebx
orl %r15d, %ebx
orl %r13d, %ebx
orl %ebp, %ebx
movl %ebx, 0x78(%r14)
xorl %eax, %eax
jmp 0x9b15
movl $0x23, %edi
callq 0x8b6c
jmp 0x9b13
movl $0x24, %edi
jmp 0x9b0e
movl $0x25, %edi
callq 0x8b94
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq