LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_program
static void target_program(void)
{
  uint32_t addr = FLASH_ADDR + target_options.offset;
  uint32_t offs = 0;
  uint32_t number_of_pages;
  uint32_t *buf = (uint32_t *)target_options.file_data;
  uint32_t size = target_options.file_size;
  int word_size = FLASH_PAGE_SIZE / sizeof(uint32_t);

  number_of_pages = (size + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;

  for (uint32_t page = 0; page < number_of_pages; page++)
  {
    // Erase Page
    dap_write_word_req(FLASH_CR, FLASH_CR_PER);
    dap_write_word_req(addr, 0);
    dap_transfer();

    flash_wait_done();

    // Program Page
    dap_write_word(FLASH_CR, FLASH_CR_PG);

    for (int i = 0; i < word_size; i++)
    {
      if (i == (word_size-1))
        dap_write_word(FLASH_CR, FLASH_CR_PG | FLASH_CR_PGSTRT);

      dap_write_word_req(addr, buf[offs]);
      addr += sizeof(uint32_t);
      offs++;
    }

    dap_transfer();

    flash_wait_done();

    if (0 == (page % STATUS_INTERVAL))
      verbose(".");
  }

  dap_write_word(FLASH_CR, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x70300(%rip), %ebp     # 0x7ee88
addl $0x7f, %ebp
cmpl $0x80, %ebp
jb 0xec45
movq 0x702f2(%rip), %r15     # 0x7ee90
movl $0x8000000, %ebx        # imm = 0x8000000
addl 0x702cf(%rip), %ebx     # 0x7ee78
shrl $0x7, %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x2, %esi
callq 0x70f4
movl %ebx, %edi
xorl %esi, %esi
callq 0x70f4
callq 0x6a6f
callq 0xeea0
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x1, %esi
callq 0x723e
xorl %r14d, %r14d
cmpl $0x1f, %r14d
jne 0xebfb
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x80001, %esi          # imm = 0x80001
callq 0x723e
leal (%r14,%r13), %eax
movl %eax, %eax
movl (%r15,%rax,4), %esi
movl %ebx, %edi
callq 0x70f4
addl $0x4, %ebx
incl %r14d
cmpl $0x20, %r14d
jne 0xebe6
callq 0x6a6f
callq 0xeea0
testb $0x1f, %r12b
jne 0xec36
leaq 0x1bf0(%rip), %rdi      # 0x1081f
xorl %eax, %eax
callq 0x7a78
addl %r14d, %r13d
incl %r12d
cmpl %ebp, %r12d
jne 0xebb2
movl $0x40022014, %edi       # imm = 0x40022014
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x723e
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_read
static void target_read(void)
{
  uint32_t addr = FLASH_ADDR + target_options.offset;
  uint32_t offs = 0;
  uint8_t *buf = target_options.file_data;
  uint32_t size = target_options.size;
  int page = 0;

  while (size)
  {
    dap_read_block(addr, &buf[offs], FLASH_PAGE_SIZE);

    addr += FLASH_PAGE_SIZE;
    offs += FLASH_PAGE_SIZE;
    size -= FLASH_PAGE_SIZE;

    if (0 == (page++ % STATUS_INTERVAL))
      verbose(".");
  }

  save_file(target_options.name, buf, target_options.size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x70110(%rip), %rbx     # 0x7ee90
movl 0x700f6(%rip), %ebp     # 0x7ee7c
testl %ebp, %ebp
je 0xedd4
movl $0x8000000, %r15d       # imm = 0x8000000
addl 0x700e1(%rip), %r15d    # 0x7ee78
leaq 0x1a81(%rip), %r14      # 0x1081f
xorl %r12d, %r12d
xorl %r13d, %r13d
leal (%r15,%r13), %edi
movl %r13d, %esi
addq %rbx, %rsi
movl $0x80, %edx
callq 0x7258
testb $0x1f, %r12b
jne 0xedc8
movq %r14, %rdi
xorl %eax, %eax
callq 0x7a78
subl $-0x80, %r13d
incl %r12d
cmpl %r13d, %ebp
jne 0xeda4
movq 0x70095(%rip), %rdi     # 0x7ee70
movl 0x7009b(%rip), %edx     # 0x7ee7c
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7e95
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_fuse_write
static void target_fuse_write(int section, uint8_t *data)
{
  uint32_t value = (data[1] << 8) | data[0];

  if (0 == section)
    dap_write_word_req(FLASH_OPTR, value);
  else if (1 == section)
    dap_write_word_req(FLASH_SDKR, value);
  else if (2 == section)
    dap_write_word_req(FLASH_BTCR, value);
  else if (3 == section)
    dap_write_word_req(FLASH_WRPR, value);
  else
    error_exit("internal: incorrect section index in target_fuse_write()");

  dap_write_word_req(FLASH_CR, FLASH_CR_OPTSTRT);
  dap_write_word_req(0x40022080, 0);
  dap_transfer();

  flash_wait_done();
}

// Assembly:
pushq %rax
cmpl $0x3, %edi
ja 0xee74
movzwl (%rsi), %esi
movl %edi, %eax
leaq 0x4e97(%rip), %rcx      # 0x13cc0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x40022020, %edi       # imm = 0x40022020
jmp 0xee4c
movl $0x40022028, %edi       # imm = 0x40022028
jmp 0xee4c
movl $0x4002202c, %edi       # imm = 0x4002202C
jmp 0xee4c
movl $0x40022024, %edi       # imm = 0x40022024
callq 0x70f4
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x20000, %esi          # imm = 0x20000
callq 0x70f4
movl $0x40022080, %edi       # imm = 0x40022080
xorl %esi, %esi
callq 0x70f4
callq 0x6a6f
popq %rax
jmp 0xeea0
leaq 0x39c1(%rip), %rdi      # 0x1283c
xorl %eax, %eax
callq 0x7c8d
jmp 0xee51
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/target_puya_py32f0.c
// Function: flash_wait_done
static void flash_wait_done(void)
{
  while (dap_read_word(FLASH_SR) & FLASH_SR_BSY);

  uint32_t sr = dap_read_word(FLASH_SR);

  if (sr & FLASH_SR_ALL_ERRORS)
    error_exit("flash operation failed. FLASH_SR = 0x%08x", sr);
}

// Assembly:
pushq %rax
movl $0x40022010, %edi       # imm = 0x40022010
callq 0x71ef
btl $0x10, %eax
jb 0xeea1
movl $0x40022010, %edi       # imm = 0x40022010
callq 0x71ef
testl $0x8010, %eax           # imm = 0x8010
je 0xeed3
leaq 0x458b(%rip), %rdi      # 0x13454
movl %eax, %esi
xorl %eax, %eax
popq %rcx
jmp 0x7c8d
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dbg_lin.c
// Function: dbg_open
void dbg_open(debugger_t *debugger, int version)
{
  g_debugger = debugger;

  g_debugger_fd = open(g_debugger->path, O_RDWR);

  if (g_debugger_fd < 0)
    error_exit("unable to open device %s: %s",  g_debugger->path, strerror(errno));

  g_debugger->use_v2 = (DBG_CMSIS_DAP_V2 == version);

  int interface = g_debugger->use_v2 ? g_debugger->v2_interface : g_debugger->v1_interface;

  { // Disconnect kernel driver
    struct usbdevfs_disconnect_claim dc;

    dc.interface = interface;
    dc.flags = USBDEVFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
    strcpy(dc.driver, "usbfs");

    int res = ioctl(g_debugger_fd, USBDEVFS_DISCONNECT_CLAIM, &dc);
    check(res >= 0, "ioctl(DISCONNECT_CLAIM): %d", res);
  }

  { // Claim interface
    int res = ioctl(g_debugger_fd, USBDEVFS_CLAIMINTERFACE, &interface);
    check(res >= 0, "ioctl(CLAIMINTERFACE): %d", res);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %esi, %ebx
movq %rdi, 0x6fb51(%rip)     # 0x7ee98
movq (%rdi), %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x6200
movl %eax, 0xcdd4(%rip)      # 0x1c130
testl %eax, %eax
jns 0xf38a
movq 0x6fb31(%rip), %rax     # 0x7ee98
movq (%rax), %r14
callq 0x6040
movl (%rax), %edi
callq 0x62a0
leaq 0x49c5(%rip), %rdi      # 0x13d42
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7c8d
movq 0x6fb07(%rip), %rax     # 0x7ee98
cmpl $0x4, %ebx
sete 0x34(%rax)
leaq 0x40(%rax), %rcx
leaq 0x58(%rax), %rax
cmoveq %rax, %rcx
movl (%rcx), %eax
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x10(%rsp), %rdx
movl %eax, (%rdx)
movabsq $0x6662737500000002, %rax # imm = 0x6662737500000002
movq %rax, 0x4(%rdx)
movw $0x73, 0xc(%rdx)
movl 0xcd62(%rip), %edi      # 0x1c130
movl $0x8004550f, %eax       # imm = 0x8004550F
leaq 0x104000c(%rax), %rsi
xorl %eax, %eax
callq 0x60f0
movl %eax, %edi
notl %edi
shrl $0x1f, %edi
leaq 0x4976(%rip), %rsi      # 0x13d65
movl %eax, %edx
xorl %eax, %eax
callq 0x7bb4
movl 0xcd32(%rip), %edi      # 0x1c130
movl $0x8004550f, %esi       # imm = 0x8004550F
movq %rbx, %rdx
xorl %eax, %eax
callq 0x60f0
movl %eax, %edi
notl %edi
shrl $0x1f, %edi
leaq 0x4966(%rip), %rsi      # 0x13d81
movl %eax, %edx
xorl %eax, %eax
callq 0x7bb4
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dbg_lin.c
// Function: dbg_close
void dbg_close(void)
{
  int interface = g_debugger->use_v2 ? g_debugger->v2_interface : g_debugger->v1_interface;

  { // Release interface
    int res = ioctl(g_debugger_fd, USBDEVFS_RELEASEINTERFACE, &interface);
    check(res >= 0, "ioctl(RELEASEINTERFACE): %d", res);
  }

  close(g_debugger_fd);
}

// Assembly:
pushq %rax
movq 0x6fa61(%rip), %rax     # 0x7ee98
leaq 0x40(%rax), %rcx
leaq 0x58(%rax), %rdx
cmpb $0x0, 0x34(%rax)
cmovneq %rdx, %rcx
movl (%rcx), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
movl 0xccda(%rip), %edi      # 0x1c130
movl $0x80045510, %esi       # imm = 0x80045510
xorl %eax, %eax
callq 0x60f0
movl %eax, %edi
notl %edi
shrl $0x1f, %edi
leaq 0x492b(%rip), %rsi      # 0x13d9b
movl %eax, %edx
xorl %eax, %eax
callq 0x7bb4
movl 0xccb1(%rip), %edi      # 0x1c130
callq 0x6120
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dbg_lin.c
// Function: get_string
static char *get_string(int fd, int index)
{
  struct usbdevfs_ctrltransfer ctrl;
  uint16_t buf[128] = { 0 };

  ctrl.bRequestType = USB_RECIP_DEVICE | USB_TYPE_STANDARD | USB_DIR_IN;
  ctrl.bRequest     = USB_REQ_GET_DESCRIPTOR;
  ctrl.wValue       = (USB_DT_STRING << 8) | index;
  ctrl.wIndex       = LANGID_US_ENGLISH;
  ctrl.wLength      = sizeof(buf);
  ctrl.data         = buf;
  ctrl.timeout      = CONTROL_TIMEOUT;

  int res = ioctl(fd, USBDEVFS_CONTROL, &ctrl);

  if (res < 0)
    return "";

  check(res >= 2 && 0 == (res % 2), "invalid string descriptor response");

  int len = res/2 - 1;
  char *str = "<unknown>";

  if (len > 0)
  {
    str = buf_alloc(len + 1);

    for (int i = 0; i < len; i++)
      str[i] = isprint(buf[i+1]) ? buf[i+1] : '?';
  }

  return str;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movl %esi, %ebx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x60e0
leaq 0x8(%rsp), %rdx
movw $0x680, (%rdx)          # imm = 0x680
orl $0x300, %ebx            # imm = 0x300
movw %bx, 0x2(%rdx)
movabsq $0x9601000409, %rax     # imm = 0x9601000409
movq %rax, 0x4(%rdx)
movq %r14, 0x10(%rdx)
movl $0xc0185500, %esi       # imm = 0xC0185500
movl %ebp, %edi
xorl %eax, %eax
callq 0x60f0
testl %eax, %eax
js 0xf774
movl %eax, %ebx
cmpl $0x2, %eax
setge %al
testb $0x1, %bl
sete %cl
andb %al, %cl
movzbl %cl, %edi
leaq 0x4780(%rip), %rsi      # 0x13eaa
xorl %eax, %eax
callq 0x7bb4
cmpl $0x4, %ebx
jb 0xf77d
shrl %ebx
leal -0x1(%rbx), %r14d
movl %ebx, %edi
callq 0x7dba
movq %rax, %rbx
callq 0x62d0
xorl %ecx, %ecx
movq (%rax), %rsi
movzwl 0x22(%rsp,%rcx,2), %edx
movzwl (%rsi,%rdx,2), %esi
btl $0xe, %esi
movl $0x3f, %esi
jae 0xf766
movl %edx, %esi
movb %sil, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0xf74d
jmp 0xf784
leaq 0x1172(%rip), %rbx      # 0x108ed
jmp 0xf784
leaq 0x4749(%rip), %rbx      # 0x13ecd
movq %rbx, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/openshmem-org[P]openshmem-examples/c/bar_pair.c
// Function: main
int
main()
{
    int me;
    int i;

    for (i = 0; i < SHMEM_BARRIER_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_init();
    me = shmem_my_pe();

    shmem_barrier_all();

    if (me == 0) {
        shmem_int_p(&x, 4, 1);
    }

    if (me == 2) {
        printf("Process %d going to sleep\n", me);
        sleep(3);
        printf("Process %d out from sleep\n", me);
    }

    printf("Process %d before barrier\n", me);
    if (me == 2 || me == 3) {
        shmem_barrier(2, 0, 2, pSync);
    }
    printf("Process %d after barrier\n", me);

    printf("%d: x = %d\n", me, x);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbx
movq $-0x1, 0x2ec0(%rip) # 0x4078
callq 0x10a0
callq 0x1080
movl %eax, %ebx
callq 0x1090
cmpl $0x2, %ebx
je 0x11ea
testl %ebx, %ebx
jne 0x121a
leaq 0x2e8f(%rip), %rdi      # 0x4068
movl $0x4, %esi
movl $0x1, %edx
callq 0x1040
jmp 0x121a
leaq 0xe13(%rip), %rdi       # 0x2004
movl $0x2, %esi
xorl %eax, %eax
callq 0x1030
movl $0x3, %edi
callq 0x1060
leaq 0xe11(%rip), %rdi       # 0x201f
movl $0x2, %esi
xorl %eax, %eax
callq 0x1030
leaq 0xe19(%rip), %rdi       # 0x203a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x124c
leaq 0x2e3d(%rip), %rcx      # 0x4078
movl $0x2, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1050
leaq 0xe02(%rip), %rdi       # 0x2055
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movl 0x2e06(%rip), %edx      # 0x4068
leaq 0xe06(%rip), %rdi       # 0x206f
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1070
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/read1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[FILESIZE];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	unlink(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));

	while (1) {
		int len = read(fd, buf, BUFLEN);
		assert(len >= 0);
		if (len == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100020, %rsp         # imm = 0x100020
movq %rdi, %rbx
movaps 0x6ff(%rip), %xmm0      # 0x3300
movq %rsp, %r14
movaps %xmm0, (%r14)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x21e0
movl %eax, %ebp
movq %r14, %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
movl $0x100000, %edx         # imm = 0x100000
xorl %esi, %esi
callq 0x2140
testl %ebp, %ebp
js 0x2cb4
leaq 0x20(%rsp), %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %ebp, %edi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2cd3
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x2160
testl %eax, %eax
js 0x2c95
leaq 0x20(%rsp), %r14
testl %eax, %eax
jne 0x2c7f
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
jns 0x2c70
leaq 0x653(%rip), %rdi       # 0x32ef
leaq 0x5e0(%rip), %rsi       # 0x3283
leaq 0x5e7(%rip), %rcx       # 0x3291
movl $0x1a, %edx
callq 0x2130
leaq 0x5c0(%rip), %rdi       # 0x327b
leaq 0x5c1(%rip), %rsi       # 0x3283
leaq 0x5c8(%rip), %rcx       # 0x3291
movl $0x15, %edx
callq 0x2130
leaq 0x5ea(%rip), %rdi       # 0x32c4
leaq 0x5a2(%rip), %rsi       # 0x3283
leaq 0x5a9(%rip), %rcx       # 0x3291
movl $0x16, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_right
int		check_right(t_map *map, int x, int y)
{
	int	i;
	int	test;

	i = 0;
	test = 0;
	while ((y + i) < map->width_map && (map->mapp[x][y + i] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x][y + i]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x][y + i] == '1')
			test = 1;
		i++;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
cmpl %edx, 0x8(%rdi)
jle 0x75b8
movq %rdi, %rbx
movslq %esi, %r15
movslq %edx, %r12
xorl %ebp, %ebp
leaq 0x7a94(%rip), %r14      # 0xf004
movl $0x1, %r13d
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movb (%rax,%r12), %al
cmpb $0x20, %al
je 0x75b0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb98c
testl %eax, %eax
je 0x75c7
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x31, (%rax,%r12)
cmovel %r13d, %ebp
movslq 0x8(%rbx), %rax
incq %r12
cmpq %rax, %r12
jl 0x7576
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a3e(%rip), %rdi      # 0xf00c
leaq 0x7a3d(%rip), %rsi      # 0xf012
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_left
int		check_left(t_map *map, int x, int y)
{
	int	test;

	test = 0;
	while (y >= 0 && (map->mapp[x][y] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x][y]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x][y] == '1')
			test = 1;
		y--;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x7649
movq %rdi, %rbx
movslq %esi, %r15
xorl %ebp, %ebp
leaq 0x7a05(%rip), %r14      # 0xf004
movl $0x1, %r12d
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movl %edx, %r13d
movb (%rax,%r13), %al
cmpb $0x20, %al
je 0x763f
movsbl %al, %esi
movq %r14, %rdi
callq 0xb98c
testl %eax, %eax
je 0x765a
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x31, (%rax,%r13)
cmovel %r12d, %ebp
leal -0x1(%r13), %edx
testl %r13d, %r13d
jg 0x7605
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
jmp 0x764b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x79ab(%rip), %rdi      # 0xf00c
leaq 0x79aa(%rip), %rsi      # 0xf012
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_above
int		check_above(t_map *map, int x, int y)
{
	int	i;
	int	test;

	i = 0;
	test = 0;
	while ((x + i) <= map->height_map && (map->mapp[x + i][y] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x + i][y]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x + i][y] == '1')
			test = 1;
		i++;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
cmpl %esi, 0xc(%rdi)
jl 0x76e0
movq %rdi, %rbx
movslq %edx, %r15
movslq %esi, %r12
xorl %ebp, %ebp
leaq 0x796c(%rip), %r14      # 0xf004
movl $0x1, %r13d
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
movb (%rax,%r15), %al
cmpb $0x20, %al
je 0x76d8
movsbl %al, %esi
movq %r14, %rdi
callq 0xb98c
testl %eax, %eax
je 0x76ef
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
cmpb $0x31, (%rax,%r15)
cmovel %r13d, %ebp
movslq 0xc(%rbx), %rax
incq %r12
cmpq %rax, %r12
jle 0x769e
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7916(%rip), %rdi      # 0xf00c
leaq 0x7915(%rip), %rsi      # 0xf012
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_below
int		check_below(t_map *map, int x, int y)
{
	int	test;

	test = 0;
	while ((x) >= 0 && (map->mapp[x][y] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x][y]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x][y] == '1')
			test = 1;
		x--;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x7771
movq %rdi, %rbx
movslq %edx, %r15
xorl %ebp, %ebp
leaq 0x78dd(%rip), %r14      # 0xf004
movl $0x1, %r12d
movq (%rbx), %rax
movl %esi, %r13d
movq (%rax,%r13,8), %rax
movb (%rax,%r15), %al
cmpb $0x20, %al
je 0x7767
movsbl %al, %esi
movq %r14, %rdi
callq 0xb98c
testl %eax, %eax
je 0x7782
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
cmpb $0x31, (%rax,%r15)
cmovel %r12d, %ebp
leal -0x1(%r13), %esi
testl %r13d, %r13d
jg 0x772d
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
jmp 0x7773
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7883(%rip), %rdi      # 0xf00c
leaq 0x7882(%rip), %rsi      # 0xf012
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_args.c
// Function: check_cub
char		*check_cub(char *argv)
{
	char	*cub_file;
	int		i;
	int		j;

	i = 0;
	if (!(cub_file = malloc(sizeof(char) * (ft_strlen(argv) + 1))))
		return (NULL);
	while (argv[i] != '\0')
	{
		cub_file[i] = argv[i];
		i++;
	}
	cub_file[i] = '\0';
	j = ft_strlen(cub_file);
	if (cub_file[j - 1] != 'b' || cub_file[j - 2] != 'u' ||
	cub_file[j - 3] != 'c' || cub_file[j - 4] != '.')
	{
		put_color(RED, "put a .cub file");
		free(cub_file);
		exit(0);
	}
	return (cub_file);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xbc3c
incl %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0x781c
movq %rax, %rbx
movb (%r14), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x77d0
movb %cl, (%rbx,%rax)
movb 0x1(%r14,%rax), %cl
incq %rax
jmp 0x77bf
movb $0x0, (%rbx,%rax)
movq %rbx, %rdi
callq 0xbc3c
cltq
cmpb $0x62, -0x1(%rbx,%rax)
jne 0x77fa
cmpb $0x75, -0x2(%rbx,%rax)
jne 0x77fa
cmpb $0x63, -0x3(%rbx,%rax)
jne 0x77fa
cmpb $0x2e, -0x4(%rbx,%rax)
je 0x781e
leaq 0x780b(%rip), %rdi      # 0xf00c
leaq 0x783e(%rip), %rsi      # 0xf046
callq 0xbf90
movq %rbx, %rdi
callq 0x7170
xorl %edi, %edi
callq 0x70a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_args.c
// Function: check_args
t_args		check_args(t_args argy, int argc, char **argv)
{
	if (argc == 2)
		argy.cub_file = check_cub(argv[1]);
	if (argc == 3)
	{
		if (ft_strcmp("--save", argv[2]) == 0)
		{
			argy.cub_file = check_cub(argv[1]);
			argy.save = 1;
		}
		else
		{
			put_color(RED,
			"\nError\n wrong arguments the first one muse be .cub file");
			exit(0);
		}
	}
	if (argc > 3)
	{
		put_color(RED, "\nError\n too many arguments");
		exit(0);
	}
	return (argy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
cmpl $0x3, %esi
je 0x7856
cmpl $0x2, %ebp
jne 0x787f
movq 0x8(%r15), %rdi
callq 0x779c
movq %rax, 0x10(%r14)
jmp 0x787f
movq 0x10(%r15), %rsi
leaq 0x77f5(%rip), %rdi      # 0xf056
callq 0xb93c
testl %eax, %eax
jne 0x78b2
movq 0x8(%r15), %rdi
callq 0x779c
movq %rax, 0x10(%r14)
movl $0x1, 0x6c(%r14)
cmpl $0x4, %ebp
jge 0x78a2
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7763(%rip), %rdi      # 0xf00c
leaq 0x77e5(%rip), %rsi      # 0xf095
jmp 0x78c0
leaq 0x7753(%rip), %rdi      # 0xf00c
leaq 0x779d(%rip), %rsi      # 0xf05d
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_args.c
// Function: valid_file
int			valid_file(t_args args)
{
	int fd;

	fd = open(args.cub_file, O_RDONLY);
	if (fd < 0)
	{
		put_color(RED, "invalid cub file");
		free(args.cub_file);
		exit(0);
	}
	return (fd);
}

// Assembly:
pushq %rbx
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7400
testl %eax, %eax
js 0x78e4
popq %rbx
retq
leaq 0x7721(%rip), %rdi      # 0xf00c
leaq 0x77be(%rip), %rsi      # 0xf0b0
callq 0xbf90
movq %rbx, %rdi
callq 0x7170
xorl %edi, %edi
callq 0x70a0
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_map.c
// Function: full_check
t_map					full_check(t_map map, int i, int j)
{
	int x;
	int y;

	x = 0;
	y = 0;
	while (y <= i)
	{
		while (map.mapp[y][x] != '\0')
		{
			if ((ft_strcmp_c("012NSWE", map.mapp[y][x]) == 0 &&
			ft_isspace(map.mapp[y][x]) == 0) && map.mapp[y][x] != 0)
			{
				put_color(RED,
				"\nError\n There is a wrong character in your map");
				exit(0);
			}
			x++;
		}
		x = 0;
		y++;
	}
	map = ft_check_map(&map, i, j);
	return (map);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %rsi, 0x8(%rsp)
testl %esi, %esi
js 0x79c2
movq 0x8(%rsp), %rax
leal 0x1(%rax), %r13d
xorl %ebp, %ebp
leaq 0x769f(%rip), %r12      # 0xf004
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
movb (%rax), %al
testb %al, %al
je 0x79ba
xorl %r15d, %r15d
movsbl %al, %esi
movq %r12, %rdi
callq 0xb98c
testl %eax, %eax
jne 0x79a7
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
movsbl (%rax,%r15), %edi
callq 0xb768
testl %eax, %eax
jne 0x79a7
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
cmpb $0x0, (%rax,%r15)
jne 0x7a22
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
movb 0x1(%rax,%r15), %al
incq %r15
testb %al, %al
jne 0x7975
incq %rbp
cmpq %r13, %rbp
jne 0x7965
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0xa2ba
movq 0x20(%r12), %rax
movq %rax, 0x20(%r14)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x75e3(%rip), %rdi      # 0xf00c
leaq 0x76b4(%rip), %rsi      # 0xf0e4
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_map.c
// Function: ft_check_borders
void					ft_check_borders(t_map *map, int x, int y)
{
	if (check_above(map, x, y) == 0)
	{
		put_color("\033[31m", "\nError\n wall missing above or wrong element");
		exit(0);
	}
	if (check_below(map, x, y) == 0)
	{
		put_color("\033[31m", "\nError\n wall missing below or wrong element");
		exit(0);
	}
	if (check_left(map, x, y) == 0)
	{
		put_color("\033[31m", "\nError\nwall missing left or wrong element");
		exit(0);
	}
	if (check_right(map, x, y) == 0)
	{
		put_color("\033[31m", "\nError\nwall missing right or wrong element");
		exit(0);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x7674
testl %eax, %eax
je 0x7a85
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x7709
testl %eax, %eax
je 0x7a95
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x75e1
testl %eax, %eax
je 0x7aa5
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x754c
testl %eax, %eax
je 0x7ab5
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7580(%rip), %rdi      # 0xf00c
leaq 0x7680(%rip), %rsi      # 0xf113
jmp 0x7ac3
leaq 0x7570(%rip), %rdi      # 0xf00c
leaq 0x769c(%rip), %rsi      # 0xf13f
jmp 0x7ac3
leaq 0x7560(%rip), %rdi      # 0xf00c
leaq 0x76b8(%rip), %rsi      # 0xf16b
jmp 0x7ac3
leaq 0x7550(%rip), %rdi      # 0xf00c
leaq 0x76d2(%rip), %rsi      # 0xf195
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_north
int			check_twice_north(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_north != -1)
	{
		put_color(RED, "\nError\n north's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x40(%rdi)
jne 0x7ae5
movq %rsi, %rdi
movl %edx, %esi
movl $0x2, %edx
jmp 0x7eec
pushq %rax
leaq 0x751f(%rip), %rdi      # 0xf00c
leaq 0x76cc(%rip), %rsi      # 0xf1c0
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_south
int			check_twice_south(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_south != -1)
	{
		put_color(RED, "\nError\n south's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x44(%rdi)
jne 0x7b15
movq %rsi, %rdi
movl %edx, %esi
movl $0x2, %edx
jmp 0x7eec
pushq %rax
leaq 0x74ef(%rip), %rdi      # 0xf00c
leaq 0x76c1(%rip), %rsi      # 0xf1e5
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_east
int			check_twice_east(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_east != -1)
	{
		put_color(RED, "\nError\n east's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x4c(%rdi)
jne 0x7b45
movq %rsi, %rdi
movl %edx, %esi
movl $0x2, %edx
jmp 0x7eec
pushq %rax
leaq 0x74bf(%rip), %rdi      # 0xf00c
leaq 0x76b6(%rip), %rsi      # 0xf20a
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_west
int			check_twice_west(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_west != -1)
	{
		put_color(RED, "\nError\n west's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x48(%rdi)
jne 0x7b75
movq %rsi, %rdi
movl %edx, %esi
movl $0x2, %edx
jmp 0x7eec
pushq %rax
leaq 0x748f(%rip), %rdi      # 0xf00c
leaq 0x76aa(%rip), %rsi      # 0xf22e
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_sprite
int			check_twice_sprite(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_sprite != -1)
	{
		put_color(RED, "\nError\n sprite's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x50(%rdi)
jne 0x7ba5
movq %rsi, %rdi
movl %edx, %esi
movl $0x2, %edx
jmp 0x7eec
pushq %rax
leaq 0x745f(%rip), %rdi      # 0xf00c
leaq 0x769e(%rip), %rsi      # 0xf252
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice_color.c
// Function: check_twice_color_f
void		check_twice_color_f(t_args *args)
{
	if (args->color_floor_r != -1 || args->color_floor_b != -1 ||
	args->color_floor_g != -1)
	{
		put_color(RED, "\nError\n floor's color is filled twice");
		exit(0);
	}
}

// Assembly:
cmpl $-0x1, 0x54(%rdi)
jne 0x7bd3
cmpl $-0x1, 0x5c(%rdi)
jne 0x7bd3
cmpl $-0x1, 0x58(%rdi)
jne 0x7bd3
retq
pushq %rax
leaq 0x7431(%rip), %rdi      # 0xf00c
leaq 0x7696(%rip), %rsi      # 0xf278
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/check_twice_color.c
// Function: check_twice_color_c
void		check_twice_color_c(t_args *args)
{
	if (args->color_ceiling_r != -1 || args->color_ceiling_b != -1 ||
	args->color_ceiling_g != -1)
	{
		put_color(RED, "\nError\n ceiling's color is filled twice");
		exit(0);
	}
}

// Assembly:
cmpl $-0x1, 0x60(%rdi)
jne 0x7c01
cmpl $-0x1, 0x68(%rdi)
jne 0x7c01
cmpl $-0x1, 0x64(%rdi)
jne 0x7c01
retq
pushq %rax
leaq 0x7403(%rip), %rdi      # 0xf00c
leaq 0x768e(%rip), %rsi      # 0xf29e
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_file_header
void		create_file_header(t_img_coord *co, int fd)
{
	int		w;
	int		h;
	int		file_size;
	int		data_start;

	w = co->argi.reso_x;
	h = co->argi.reso_y;
	file_size = w * h * 4 + 54;
	data_start = 14 + 40;
	write(fd, "BM", 2);
	write(fd, &file_size, 4);
	write(fd, "\0\0\0\0", 4);
	write(fd, &data_start, 4);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl 0x140(%rdi), %eax
imull 0x144(%rdi), %eax
leal 0x36(,%rax,4), %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
leaq 0x8(%rsp), %r14
movl $0x36, (%r14)
leaq 0x7670(%rip), %rsi      # 0xf2c6
movl $0x2, %edx
movl %ebx, %edi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x73b0
leaq 0x768b(%rip), %rsi      # 0xf303
movl $0x4, %edx
movl %ebx, %edi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_info_header_1
void		create_info_header_1(t_img_coord *co, int fd)
{
	int		size_header;
	int		w;
	int		h;
	short	plane;
	short	bpp;

	plane = 1;
	w = co->argi.reso_x;
	h = co->argi.reso_y;
	size_header = 40;
	bpp = co->img->bits_per_pixel;
	write(fd, &size_header, 4);
	write(fd, &w, 4);
	write(fd, &h, 4);
	write(fd, &plane, 2);
	write(fd, &bpp, 2);
	write(fd, "\0\0\0\0", 4);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x2(%rsp), %r14
movw $0x1, (%r14)
movl 0x140(%rdi), %eax
leaq 0x8(%rsp), %r12
movl %eax, (%r12)
movl 0x144(%rdi), %eax
leaq 0x4(%rsp), %r13
movl %eax, (%r13)
leaq 0xc(%rsp), %rsi
movl $0x28, (%rsi)
movq 0x130(%rdi), %rax
movzwl 0x10(%rax), %eax
movq %rsp, %r15
movw %ax, (%r15)
movl $0x4, %edx
movl %ebx, %edi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r12, %rsi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r13, %rsi
callq 0x73b0
movl $0x2, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73b0
movl $0x2, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x73b0
leaq 0x75c2(%rip), %rsi      # 0xf303
movl $0x4, %edx
movl %ebx, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x73b0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_info_header_2
void		create_info_header_2(int fd, t_img_coord *co)
{
	int		img_size;
	int		color;
	int		w;
	int		h;

	h = co->argi.reso_y - 1;
	w = co->argi.reso_x;
	img_size = w * h * 4;
	color = 0;
	write(fd, &img_size, 4);
	write(fd, &color, 4);
	write(fd, &color, 4);
	write(fd, &color, 4);
	write(fd, &color, 4);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x144(%rsi), %eax
leal -0x4(,%rax,4), %eax
imull 0x140(%rsi), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rsp, %r14
movl $0x0, (%r14)
movl $0x4, %edx
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73b0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_info_image
void		create_info_image(t_img_coord *co, int fd)
{
	int		w;
	int		h;
	int		y;
	int		r;
	int		x;

	w = co->argi.reso_x;
	h = co->argi.reso_y;
	y = h - 1;
	r = 0x00ffffff;
	while (y >= 0)
	{
		x = 0;
		while (x < w)
		{
			r = (*(int*)(co->img->addr + (y * co->img->line_length + (x * 4))));
			write(fd, &r, 4);
			x++;
		}
		y--;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x140(%rdi), %r12d
movl 0x144(%rdi), %eax
movl $0xffffff, 0xc(%rsp)    # imm = 0xFFFFFF
testl %eax, %eax
jle 0x7e5e
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%rsp)
leaq 0xc(%rsp), %r15
movq %rax, 0x10(%rsp)
testl %r12d, %r12d
jle 0x7e4d
movslq 0x8(%rsp), %r13
xorl %ebp, %ebp
movq 0x130(%r14), %rax
movslq 0x14(%rax), %rcx
imulq %r13, %rcx
addq 0x8(%rax), %rcx
movl (%rcx,%rbp,4), %eax
movl %eax, 0xc(%rsp)
movl $0x4, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x73b0
incq %rbp
cmpl %ebp, %r12d
jne 0x7e1c
movq 0x10(%rsp), %rcx
leal -0x1(%rcx), %eax
decl 0x8(%rsp)
cmpl $0x2, %ecx
jge 0x7e0b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_bmp
void		create_bmp(t_img_coord *co)
{
	char	*titre;
	int		fd;

	titre = "first_image.bmp";
	put_color("\033[038;5:212m", "\nSAVE under first_image.bmp\n");
	fd = open(titre, O_CREAT | O_WRONLY, 00700);
	create_file_header(co, fd);
	create_info_header_1(co, fd);
	create_info_header_2(fd, co);
	create_info_image(co, fd);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x745f(%rip), %rdi      # 0xf2d9
leaq 0x7465(%rip), %rsi      # 0xf2e6
callq 0xbf90
leaq 0x743c(%rip), %rdi      # 0xf2c9
movl $0x41, %esi
movl $0x1c0, %edx            # imm = 0x1C0
xorl %eax, %eax
callq 0x7400
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x7c1c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7c9d
movl %ebp, %edi
movq %rbx, %rsi
callq 0x7d5a
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7dd3
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/general.c
// Function: ft_check
int			ft_check(t_args *args)
{
	if (args->reso_x == -1 || args->reso_y == -1 || args->text_sprite == NULL ||
	args->color_floor_r == -1 || args->color_floor_b == -1 ||
	args->color_floor_g == -1 || args->color_ceiling_r == -1 ||
	args->color_ceiling_b == -1 || args->color_ceiling_g == -1)
	{
		return (1);
	}
	else
	{
		return (0);
	}
	return (0);
}

// Assembly:
movl $0x1, %eax
cmpl $-0x1, 0x8(%rdi)
je 0x7fd3
cmpl $-0x1, 0xc(%rdi)
je 0x7fd3
cmpq $0x0, 0x38(%rdi)
je 0x7fd3
cmpl $-0x1, 0x54(%rdi)
je 0x7fd3
cmpl $-0x1, 0x5c(%rdi)
je 0x7fd3
cmpl $-0x1, 0x58(%rdi)
je 0x7fd3
cmpl $-0x1, 0x60(%rdi)
je 0x7fd3
cmpl $-0x1, 0x68(%rdi)
je 0x7fd3
xorl %eax, %eax
cmpl $-0x1, 0x64(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/general.c
// Function: verif_args
void		verif_args(t_args *args)
{
	if (args->reso_y == -1 || args->reso_x == -1)
	{
		put_color(RED, "\nError\n wrong format for resolution or missing");
		exit(0);
	}
	if (args->text_sprite == NULL)
	{
		put_color(RED, "\nError\n missing path for sprite");
		exit(0);
	}
	if (args->color_ceiling_r == -1 || args->color_ceiling_b == -1 ||
	args->color_ceiling_g == -1)
	{
		put_color(RED, "\nError\n wrong format for color or missing");
		exit(0);
	}
	if (args->color_floor_r == -1 || args->color_floor_b == -1 ||
	args->color_floor_g == -1)
	{
		put_color(RED, "\nError\n wrong format for color or missing");
		exit(0);
	}
	verif_texture(args);
}

// Assembly:
pushq %rax
cmpl $-0x1, 0xc(%rdi)
je 0x8022
cmpl $-0x1, 0x8(%rdi)
je 0x8022
cmpq $0x0, 0x38(%rdi)
je 0x8032
cmpl $-0x1, 0x60(%rdi)
je 0x8012
cmpl $-0x1, 0x68(%rdi)
je 0x8012
cmpl $-0x1, 0x64(%rdi)
je 0x8012
cmpl $-0x1, 0x54(%rdi)
je 0x8012
cmpl $-0x1, 0x5c(%rdi)
je 0x8012
cmpl $-0x1, 0x58(%rdi)
je 0x8012
popq %rax
jmp 0x7f21
leaq 0x6ff3(%rip), %rdi      # 0xf00c
leaq 0x7379(%rip), %rsi      # 0xf399
jmp 0x8040
leaq 0x6fe3(%rip), %rdi      # 0xf00c
leaq 0x731a(%rip), %rsi      # 0xf34a
jmp 0x8040
leaq 0x6fd3(%rip), %rdi      # 0xf00c
leaq 0x7339(%rip), %rsi      # 0xf379
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/general.c
// Function: empty
t_args		empty(t_args args, int fd, char *line)
{
	int i;

	verif_args(&args);
	if (ft_empty_line(line) == 1)
	{
		put_color(RED, "\nError\n something is wrong ");
		free(line);
		exit(0);
	}
	free(line);
	while ((i = get_next_line(fd, &line)) == 1 && ft_empty_line(line) == 0)
	{
		args.ready_count++;
		free(line);
		line = NULL;
	}
	free(line);
	return (args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %rdx, (%rsp)
movq %r14, %rdi
callq 0x7fd4
movq (%rsp), %rdi
callq 0xb8ac
cmpl $0x1, %eax
je 0x80ec
movq %rsp, %r15
movq (%r15), %rdi
callq 0x7170
movl %ebp, %edi
movq %r15, %rsi
callq 0xbb6b
cmpl $0x1, %eax
jne 0x80c5
movq %rsp, %r15
movq (%rsp), %rdi
callq 0xb8ac
testl %eax, %eax
jne 0x80c5
incl 0x7c(%r14)
movq (%rsp), %rdi
callq 0x7170
movq $0x0, (%rsp)
movl %ebp, %edi
movq %r15, %rsi
callq 0xbb6b
cmpl $0x1, %eax
je 0x8094
movq (%rsp), %rdi
callq 0x7170
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6f19(%rip), %rdi      # 0xf00c
leaq 0x72c9(%rip), %rsi      # 0xf3c3
callq 0xbf90
movq (%rsp), %rdi
callq 0x7170
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/general.c
// Function: parse_cub
t_args		parse_cub(t_args args)
{
	int		fd;
	char	*line;
	int		i;

	args = create_t_args(args);
	i = 1;
	fd = valid_file(args);
	while ((i = get_next_line(fd, &line)) == 1 && ft_check(&args) == 1)
	{
		args = ft_parse_arg(line, args);
		args.ready_count++;
		free(line);
	}
	args = empty(args, fd, line);
	while ((i = get_next_line(fd, &line)) > 0 && ft_check(&args) == 0)
	{
		args.ready_s = ft_compare(ft_strlen(line), args.ready_s);
		args.ready_j++;
		free(line);
	}
	free(line);
	args.ready_j += 2;
	close(fd);
	return (args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
leaq 0x150(%rsp), %r14
movl $0x11, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x98(%rsp), %r15
movq %r15, %rdi
callq 0x9c6e
movl $0x88, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x73f0
movl $0x11, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x78cc
movl %eax, %ebp
leaq 0x90(%rsp), %rsi
movl %eax, %edi
callq 0xbb6b
cmpl $0x1, %eax
jne 0x81ed
leaq 0x98(%rsp), %r15
leaq 0x90(%rsp), %r12
movq %r14, %rdi
callq 0x7f94
testl %eax, %eax
je 0x81ed
movq 0x90(%rsp), %rax
movl $0x11, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
movq %rax, %rsi
callq 0x9ddc
movl $0x88, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x73f0
incl 0x7c(%r14)
movq 0x90(%rsp), %rdi
callq 0x7170
movl %ebp, %edi
movq %r12, %rsi
callq 0xbb6b
cmpl $0x1, %eax
je 0x8190
leaq 0x90(%rsp), %r15
movq (%r15), %rdx
movl $0x11, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x804c
movl $0x88, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x73f0
movl %ebp, %edi
movq %r15, %rsi
callq 0xbb6b
testl %eax, %eax
jle 0x8285
leaq 0x90(%rsp), %r15
movq %r14, %rdi
callq 0x7f94
testl %eax, %eax
jne 0x8285
movq 0x90(%rsp), %rdi
callq 0xbc3c
movl 0x78(%r14), %esi
movl %eax, %edi
callq 0xb8a4
movl %eax, 0x78(%r14)
incl 0x74(%r14)
movq 0x90(%rsp), %rdi
callq 0x7170
movl %ebp, %edi
movq %r15, %rsi
callq 0xbb6b
testl %eax, %eax
jg 0x823e
movq 0x90(%rsp), %rdi
callq 0x7170
addl $0x2, 0x74(%r14)
movl %ebp, %edi
callq 0x7040
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/general.c
// Function: main
int			main(int argc, char **argv)
{
	t_map	mapy;
	t_args	argy;

	argy.save = 0;
	if (argc > 0)
		put_color("\033[36m", "\nHello\n");
	if (argc == 1)
	{
		put_color(RED, "\nError\n too few arguments");
		exit(0);
	}
	argy = check_args(argy, argc, argv);
	argy = parse_cub(argy);
	if (ft_check(&argy) == 0 && argy.ready_j > 0)
		mapy = ft_parse_map(argy.ready_j, argy.ready_s, argy.ready_count,
		argy.cub_file);
	if (ft_check(&argy) == 0 && argy.ready_j > 0)
		ft_graph(argy, mapy);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movl %edi, %ebp
movl $0x0, 0x124(%rsp)
testl %edi, %edi
jle 0x82f5
leaq 0x70f6(%rip), %rdi      # 0xf3df
leaq 0x70f5(%rip), %rsi      # 0xf3e5
callq 0xbf90
cmpl $0x1, %ebp
je 0x841c
leaq 0xb8(%rsp), %rbx
movl $0x11, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x140(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x7829
movl $0x88, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73f0
movl $0x11, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x140(%rsp), %r14
movq %r14, %rdi
callq 0x810f
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rdi
callq 0x7f94
testl %eax, %eax
sete %al
movl 0x74(%rbx), %esi
testl %esi, %esi
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x83a6
movl 0x130(%rsp), %edx
movl 0x134(%rsp), %ecx
movq 0xc8(%rsp), %r8
leaq 0x140(%rsp), %rdi
callq 0xa452
leaq 0xb8(%rsp), %rdi
callq 0x7f94
testl %eax, %eax
jne 0x8409
cmpl $0x0, 0x12c(%rsp)
jle 0x8409
leaq 0xb8(%rsp), %rsi
movl $0x11, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq 0x160(%rsp), %rax
movq %rax, 0xa8(%rsp)
movups 0x140(%rsp), %xmm0
movups 0x150(%rsp), %xmm1
movups %xmm1, 0x98(%rsp)
movups %xmm0, 0x88(%rsp)
callq 0x8581
movl $0x1, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6be9(%rip), %rdi      # 0xf00c
leaq 0x6fc3(%rip), %rsi      # 0xf3ed
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/graph.c
// Function: my_loop
int				my_loop(t_img_coord *co)
{
	if (co->key->w)
		move_forward(co);
	if (co->key->s)
		move_backward(co);
	if (co->key->a)
		move_left(co);
	if (co->key->d)
		move_right(co);
	if (co->key->ro_left)
		rotate_left(co);
	if (co->key->ro_right)
		rotate_right(co);
	manage_3d(co);
	mlx_do_sync(co->mlx.mlx);
	return (0);
}

// Assembly:
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, %rbx
movq 0xd8(%rdi), %rax
cmpl $0x0, (%rax)
je 0x84a2
movq %rbx, %rdi
callq 0x99ec
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x4(%rax)
je 0x84b7
movq %rbx, %rdi
callq 0x9a82
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x84cc
movq %rbx, %rdi
callq 0x9ba4
movq 0xd8(%rbx), %rax
cmpl $0x0, 0xc(%rax)
je 0x84e1
movq %rbx, %rdi
callq 0x9b13
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x14(%rax)
je 0x84f6
movq %rbx, %rdi
callq 0xaf3f
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x10(%rax)
je 0x850b
movq %rbx, %rdi
callq 0xaeb8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xb038
movq 0x110(%rbx), %rdi
callq 0xe640
xorl %eax, %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/graph.c
// Function: init_img
t_img			*init_img(t_mlx_coord xco, t_args argy)
{
	t_img		*img;

	if (!(img = malloc(sizeof(t_img))))
		return (NULL);
	img->img = mlx_new_image(xco.mlx, argy.reso_x, argy.reso_y);
	img->addr = mlx_get_data_addr(img->img, &img->bits_per_pixel,
	&img->line_length, &img->endian);
	return (img);
}

// Assembly:
pushq %rbx
movl $0x28, %edi
callq 0x7100
testq %rax, %rax
je 0x857a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0xcb70
movq %rax, (%rbx)
leaq 0x10(%rbx), %rsi
leaq 0x14(%rbx), %rdx
movq %rbx, %rcx
addq $0x18, %rcx
movq %rax, %rdi
callq 0xcdf0
movq %rax, 0x8(%rbx)
jmp 0x857c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/handle_key.c
// Function: free_texture
void	free_texture(t_img_coord *co)
{
	int i;

	i = 0;
	while (i < 4)
	{
		if (co->text[i]->error == 1)
		{
			mlx_destroy_image(co->text[i]->mlx, co->text[i]->img);
			free(co->text[i]);
		}
		i++;
	}
	free(co->argi.cub_file);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0xf0(%rbx,%r14,8), %rax
cmpl $0x1, 0x50(%rax)
jne 0x8899
movq (%rax), %rdi
movq 0x28(%rax), %rsi
callq 0xe650
movq 0xf0(%rbx,%r14,8), %rdi
callq 0x7170
incq %r14
cmpq $0x4, %r14
jne 0x8872
movq 0x148(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7170
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/handle_key.c
// Function: handle_exit
void	handle_exit(t_img_coord *co)
{
	int i;

	i = 0;
	mlx_destroy_image(co->text_sp->mlx, co->text_sp->img);
	free(co->text_sp);
	free(co->calc);
	free(co->buf_sprit);
	free(co->key);
	free_texture(co);
	while (i < co->mapi.height_map + 1)
	{
		free(co->mapi.mapp[i]);
		i++;
	}
	free(co->mapi.mapp);
	free(co->argi.text_sprite);
	free(co->mapi.sprite);
	free(co->argi.text_west);
	free(co->argi.text_north);
	free(co->argi.text_east);
	free(co->argi.text_south);
	mlx_destroy_image(co->mlx.mlx, co->img->img);
	if (co->argi.save == 0)
		mlx_destroy_window(co->mlx.mlx, co->mlx.mlx_win);
	free(co->img);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe0(%rdi), %rax
movq (%rax), %rdi
movq 0x28(%rax), %rsi
callq 0xe650
movq 0xe0(%rbx), %rdi
callq 0x7170
movq 0xe8(%rbx), %rdi
callq 0x7170
movq 0xc0(%rbx), %rdi
callq 0x7170
movq 0xd8(%rbx), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x8868
cmpl $0x0, 0x1cc(%rbx)
js 0x8937
movq $-0x1, %r14
movq 0x1c0(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0x7170
movslq 0x1cc(%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0x8917
movq 0x1c0(%rbx), %rdi
callq 0x7170
movq 0x170(%rbx), %rdi
callq 0x7170
movq 0x1e0(%rbx), %rdi
callq 0x7170
movq 0x160(%rbx), %rdi
callq 0x7170
movq 0x150(%rbx), %rdi
callq 0x7170
movq 0x168(%rbx), %rdi
callq 0x7170
movq 0x158(%rbx), %rdi
callq 0x7170
movq 0x110(%rbx), %rdi
movq 0x130(%rbx), %rax
movq (%rax), %rsi
callq 0xe650
cmpl $0x0, 0x1a4(%rbx)
jne 0x89bd
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
callq 0xe0a0
movq 0x130(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7170