LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_16/longest_line.c
// Function: get_line
int get_line(char line[], int maxline)
{
  int c, i;

  for (i = 0; i < maxline - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }
  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }
  
  line[i] = '\0';
  
  while(c != EOF && c != '\n')
  {
    ++i;
    c = getchar();
  }
  
  if (c == '\n')
    ++i;

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x2, %esi
jl 0x1209
movl %esi, %ebx
decl %ebx
movl %ebx, %r12d
xorl %r15d, %r15d
callq 0x1040
cmpl $-0x1, %eax
je 0x120d
cmpl $0xa, %eax
je 0x120d
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %r12
jne 0x11ec
jmp 0x1210
xorl %ebx, %ebx
jmp 0x1210
movl %r15d, %ebx
cmpl $0xa, %eax
jne 0x121e
movl %ebx, %ecx
movb $0xa, (%r14,%rcx)
incl %ebx
movslq %ebx, %rcx
movb $0x0, (%r14,%rcx)
cmpl $-0x1, %eax
je 0x1239
incl %ebx
cmpl $0xa, %eax
je 0x1239
callq 0x1040
jmp 0x1226
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/gen.c
// Function: safe_open
FILE *safe_open(const char *name, const char *mode)
{
	FILE *f = fopen(name, mode);
	if (!f) {
		perror(name);
		exit(1);
	}
	return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x10b0
testq %rax, %rax
je 0x12bc
popq %rbx
retq
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/gen.c
// Function: instr_len
int instr_len(const char *args)
{
	const char *c;
	int len = 1; /* opcode length is 1 */

	for (c = args; *c; ++c)
		len += oplen(*c);

	return len;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb (%rdi), %al
testb %al, %al
je 0x1324
movq %rdi, %rbx
incq %rbx
movl $0x1, %ebp
movsbl %al, %edi
callq 0x12df
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x130f
jmp 0x1329
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/gen.c
// Function: read_file
void read_file(const char *fname, void (*fn)(FILE *f, void *ctx), void *ctx)
{
	FILE *in = safe_open(fname, "r");

	for (;;) {
		int c = fgetc(in);

		if (c == EOF)
			break;
		if (c == '\n')
			continue;
		if (c == '#')
			goto nextline;

		ungetc(c, in);
		(*fn)(in, ctx);
nextline:
		do {
			c = fgetc(in);
		} while (c != '\n' && c != EOF);
	}
	fclose(in);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xd6f(%rip), %rsi       # 0x20b3
callq 0x12ac
movq %rax, %r15
movq %r15, %rdi
callq 0x1070
cmpl $0xa, %eax
je 0x134c
cmpl $0x23, %eax
je 0x1376
cmpl $-0x1, %eax
je 0x138a
movl %eax, %edi
movq %r15, %rsi
callq 0x10a0
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
movq %r15, %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0x134c
cmpl $0xa, %eax
jne 0x1376
jmp 0x134c
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/gen.c
// Function: read_operands
void read_operands(FILE *in, void *ctx)
{
	char op;
	int len;

	(void)ctx;
	if (fscanf(in, "%c %d", &op, &len) != 2) {
		fprintf(stderr, "operand parse error near byte %ld\n", ftell(in));
		exit(1);
	}
	if (lens[op] != -1) {
		fprintf(stderr, "'%c': operand duplicated\n", op);
		exit(1);
	}
	lens[op] = len;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xcf9(%rip), %rsi       # 0x20b5
leaq 0xb(%rsp), %rdx
leaq 0xc(%rsp), %rcx
xorl %eax, %eax
callq 0x1030
cmpl $0x2, %eax
jne 0x13f2
movsbq 0xb(%rsp), %rdi
leaq 0x2cb1(%rip), %rax      # 0x4090
cmpl $-0x1, (%rax,%rdi,4)
jne 0x13fa
movl 0xc(%rsp), %ecx
movl %ecx, (%rax,%rdi,4)
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x1134
callq 0x1160
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/gen.c
// Function: write_table
void write_table(FILE *in, void *ctx)
{
	FILE *out = ctx;
	char name[16], args[8], code[3];

	if (fscanf(in, "%15s %7s %2s", name, args, code) != 3) {
		fprintf(stderr, "instruction parse error near byte %ld\n", ftell(in));
		exit(1);
	}
	fprintf(out, "\t{ \"%s\", { 0x%s, %d, \"%s\" } },\n",
			name, code, instr_len(args), args);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xce4(%rip), %rsi       # 0x20f8
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x5(%rsp), %r8
xorl %eax, %eax
callq 0x1030
cmpl $0x3, %eax
jne 0x1481
movb 0x8(%rsp), %al
movl $0x1, %ebp
testb %al, %al
je 0x1455
leaq 0x9(%rsp), %r14
movsbl %al, %edi
callq 0x12df
addl %eax, %ebp
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x1441
leaq 0xcd0(%rip), %rsi       # 0x212c
leaq 0x10(%rsp), %rdx
leaq 0x5(%rsp), %rcx
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x1080
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x1188
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/gen.c
// Function: main
int main(void)
{
	FILE *out;

	init_operands();
	read_file(oper_name, read_operands, NULL);

	out = safe_open(out_name, "w");
	fputs(head, out);
	read_file(instr_name, write_table, out);
	fputs(tail, out);
	safe_close(out_name, out);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2bfc(%rip), %rdi      # 0x4090
movl $0x400, %edx            # imm = 0x400
movl $0xff, %esi
callq 0x1060
leaq 0xb66(%rip), %rdi       # 0x2010
leaq -0x104(%rip), %rsi      # 0x13ad
xorl %edx, %edx
callq 0x1332
leaq 0xb73(%rip), %rbx       # 0x2032
leaq 0xc86(%rip), %rsi       # 0x214c
movq %rbx, %rdi
callq 0x12ac
movq %rax, %r14
leaq 0xb68(%rip), %rdi       # 0x2040
movq %rax, %rsi
callq 0x1050
leaq 0xb3c(%rip), %rdi       # 0x2023
leaq -0xef(%rip), %rsi       # 0x13ff
movq %r14, %rdx
callq 0x1332
leaq 0xb9e(%rip), %rdi       # 0x209b
movq %r14, %rsi
callq 0x1050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pyk[P]simple-nn/deps/pcg/src/pcg-advance-16.c
// Function: pcg_advance_lcg_16
uint16_t pcg_advance_lcg_16(uint16_t state, uint16_t delta, uint16_t cur_mult,
                            uint16_t cur_plus)
{
    uint16_t acc_mult = 1u;
    uint16_t acc_plus = 0u;
    while (delta > 0) {
        if (delta & 1) {
            acc_mult *= cur_mult;
            acc_plus = acc_plus * cur_mult + cur_plus;
        }
        cur_plus = (cur_mult + 1) * cur_plus;
        cur_mult *= cur_mult;
        delta /= 2;
    }
    return acc_mult * state + acc_plus;
}

// Assembly:
testl %esi, %esi
je 0x16fb
pushq %rbx
movw $0x1, %r8w
xorl %r10d, %r10d
movl $0x1, %r9d
movl %r10d, %eax
imull %edx, %eax
addl %ecx, %eax
testb $0x1, %sil
movl %edx, %r11d
cmovel %r9d, %r11d
movzwl %si, %ebx
cmovel %r10d, %eax
imull %r11d, %r8d
leal 0x1(%rdx), %r11d
imull %ecx, %r11d
imull %edx, %edx
movl %ebx, %esi
shrl %esi
movl %eax, %r10d
movl %r11d, %ecx
cmpw $0x1, %bx
ja 0x16bf
popq %rbx
jmp 0x1702
movw $0x1, %r8w
xorl %eax, %eax
imull %edi, %r8d
addl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/arachsys[P]init/pivot.c
// Function: main
int main(int argc, char **argv) {
  int old, new;

  if (argc < 2) {
    fprintf(stderr, "Usage: %s NEW-ROOT [PUT-OLD]\n", argv[0]);
    return 64;
  }

  if (argc > 2) {
    if (syscall(__NR_pivot_root, argv[1], argv[2]) < 0)
      err(EXIT_FAILURE, "cannot pivot to new root %s", argv[1]);
    return EXIT_SUCCESS;
  }

  if (old = open("/", O_DIRECTORY | O_RDONLY), old < 0)
    err(EXIT_FAILURE, "cannot open /");
  if (new = open(argv[1], O_DIRECTORY | O_RDONLY), new < 0)
    err(EXIT_FAILURE, "cannot open %s", argv[1]);
  if (fchdir(new) < 0 || syscall(__NR_pivot_root, ".", ".") < 0)
    err(EXIT_FAILURE, "cannot pivot to new root %s", argv[1]);

  if (fchdir(old) < 0)
    err(EXIT_FAILURE, "cannot re-enter old root");
  if (mount("", ".", "", MS_SLAVE | MS_REC, NULL) < 0)
    err(EXIT_FAILURE, "cannot disable old root mount propagation");
  if (umount2(".", MNT_DETACH) < 0)
    err(EXIT_FAILURE, "cannot detach old root");

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x12b2
cmpl $0x2, %edi
jne 0x128e
leaq 0xe6e(%rip), %rdi       # 0x204a
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
callq 0x1090
testl %eax, %eax
js 0x12cf
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
callq 0x1090
testl %eax, %eax
js 0x12d8
movl %eax, %edi
callq 0x1080
testl %eax, %eax
js 0x12c2
leaq 0xe3b(%rip), %rdx       # 0x205b
movl $0x9b, %edi
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1060
testq %rax, %rax
js 0x12c2
movl %ebp, %edi
callq 0x1080
testl %eax, %eax
js 0x12ef
leaq 0xe0d(%rip), %rsi       # 0x205b
leaq 0xdcc(%rip), %rdi       # 0x2021
xorl %r14d, %r14d
movl $0x84000, %ecx          # imm = 0x84000
movq %rdi, %rdx
xorl %r8d, %r8d
callq 0x1040
testl %eax, %eax
js 0x12f8
leaq 0xde4(%rip), %rdi       # 0x205b
movl $0x2, %esi
callq 0x1030
testl %eax, %eax
jns 0x12aa
leaq 0xe14(%rip), %rsi       # 0x20a0
jmp 0x12ff
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
xorl %r14d, %r14d
movl $0x9b, %edi
xorl %eax, %eax
callq 0x1060
testq %rax, %rax
js 0x12c2
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x10b0
movl $0x40, %r14d
jmp 0x12aa
movq 0x8(%rbx), %rdx
leaq 0xd55(%rip), %rsi       # 0x2022
jmp 0x12e3
leaq 0xd68(%rip), %rsi       # 0x203e
jmp 0x12ff
movq 0x8(%rbx), %rdx
leaq 0xd69(%rip), %rsi       # 0x204c
movl $0x1, %edi
xorl %eax, %eax
callq 0x1070
leaq 0xd67(%rip), %rsi       # 0x205d
jmp 0x12ff
leaq 0xd77(%rip), %rsi       # 0x2076
movl $0x1, %edi
xorl %eax, %eax
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/gmcvicker[P]check_fastq/split_fastq.c
// Function: check_line_len
static void check_line_len(ReadSeq *read, char *line, gzFile f) {
  size_t len, n;
  char c;

  len = strlen(line);
  if(len == 0) {
    return;
  }
  if(line[len-1] == '\n') {
    return;
  }
  
  /* line did not terminate with a '\n' */
  my_warn("%s:%d: line did not terminate with '\\n':  \n'%s'\n", 
          __FILE__, __LINE__, line, len);

  read->status = FASTQ_ERR;

  /* seek in file until next '\n' is found */
  n = 0;
  while((c = gzgetc(f)) != -1) {
    n++;

    if(n < 10) {
      if(isprint(c)) {
        fprintf(stderr, "  extra character %ld: '%c'\n", n, c);
      }
      else {
        fprintf(stderr, "  unprintable extra character %ld: '\\%d'\n", n, c);
      }
    } else if(n == 10) {
      fprintf(stderr, "  ...\n");      
    }
    
    if(c == '\n') {
      fprintf(stderr, "  read %ld extra characters to reach end of line\n", n);
      return;
    }
  }

  fprintf(stderr, "  read %ld extra characters to reach end of file\n", n);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1110
testq %rax, %rax
je 0x1e75
cmpb $0xa, -0x1(%r15,%rax)
jne 0x1e84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23eb(%rip), %rdi      # 0x4276
leaq 0x21d4(%rip), %rsi      # 0x4066
movl $0x44, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1c5b
movl $0x1, 0x1420(%r14)
movq 0x5142(%rip), %r15      # 0x6ff8
xorl %r14d, %r14d
movq %r14, %r12
movl (%rbx), %eax
testl %eax, %eax
je 0x1edb
decl %eax
movl %eax, (%rbx)
incq 0x10(%rbx)
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %r13b
jmp 0x1ee6
movq %rbx, %rdi
callq 0x10f0
movl %eax, %r13d
cmpb $-0x1, %r13b
je 0x1f44
leaq 0x1(%r12), %r14
cmpq $0x9, %r14
jbe 0x1f05
cmpq $0x9, %r12
je 0x1f27
cmpb $0xa, %r13b
jne 0x1eb9
jmp 0x1f53
movsbl %r13b, %r12d
callq 0x12a0
movq (%rax), %rax
movslq %r12d, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
movq (%r15), %rdi
jne 0x1f2e
leaq 0x239f(%rip), %rsi      # 0x42c4
jmp 0x1f35
callq 0x1c2c
jmp 0x1efd
leaq 0x2372(%rip), %rsi      # 0x42a7
movq %r14, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1180
jmp 0x1efd
movq (%r15), %rdi
leaq 0x23d9(%rip), %rsi      # 0x4327
movq %r12, %rdx
jmp 0x1f60
movq (%r15), %rdi
leaq 0x2398(%rip), %rsi      # 0x42f5
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Marinouel[P]Network-Lab/client.c
// Function: writen
ssize_t writen(int fd, const void *vptr, size_t n)				//function given from the lessons
 {
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;
    ptr = vptr;
	nleft = n;
	while (nleft > 0) {

		if  ((nwritten = write(fd, ptr, nleft)) <= 0 ){ 
			if (errno == EINTR) 
				nwritten = 0;
          	else 
          		return -1; /* error */ 
		} 
		nleft -= nwritten;
        ptr += nwritten;
	} 
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1258
movq %rsi, %r14
movl %edi, %r15d
movq %rbx, %r12
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1060
testq %rax, %rax
jg 0x1247
callq 0x1050
cmpl $0x4, (%rax)
jne 0x1251
xorl %eax, %eax
addq %rax, %r14
subq %rax, %r12
jne 0x1228
jmp 0x1258
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.5/sigusr1.c
// Function: main
int main ()
{
	struct sigaction sa;
	memset (&sa, 0, sizeof (sa));
	sa.sa_handler = &handler;
	sigaction (SIGUSR1, &sa, NULL);
	int pid = (int) getpid();
	for (int i=0; i<10; i++)	
        kill(pid, SIGUSR1);
	printf ("SIGUSR1 was raised %d times\n", sigusr1_count);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
leaq -0xa8(%rbp), %rbx
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1040
leaq -0x37(%rip), %rax       # 0x117c
movq %rax, (%rbx)
movl $0xa, %r14d
movl $0xa, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1050
callq 0x1070
movl %eax, %ebx
movl %ebx, %edi
movl $0xa, %esi
callq 0x1060
decl %r14d
jne 0x11d2
movl 0x2e6b(%rip), %esi      # 0x4054
leaq 0xe14(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_06/psprintf.c
// Function: main
int main(int argc, char *argv[])
{
	char *msg;
	int ret;

        if (argc < 2) {
                fprintf(stderr, "usage: %s <prefix>\n",
                        argv[0]);
                return -1;
        }

	/* Format the message with the supplied prefix */
	ret = psprintf(&msg, argv[1],
		"some data: %d, %c\n", 10, 'x');
	if (ret < 0) {
		fprintf(stderr, "psprintf error\n");
		return -1;
	}

	/* Print the message on stdout */
	fputs(msg, stdout);

	/* Free the allocated memory buffer */
	free(msg);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x123c
movq 0x8(%rsi), %rsi
xorl %ebx, %ebx
movq %rsp, %rdi
movl $0xa, %ecx
movl $0x78, %r8d
xorl %eax, %eax
callq 0x1252
testl %eax, %eax
js 0x1246
movq (%rsp), %r14
movq 0x2db9(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rdi
callq 0x10dc
jmp 0x124b
callq 0x10c0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1232
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_06/psprintf.c
// Function: psprintf
static int psprintf(char **str, const char *name,
		const char *fmt, ...)
{
	int size;
	char *nfmt;
	va_list ap;
	int ret;

	/* Compute the new format size.
	 *
	 * The new format string is formed as:
	 *     <name>: <fmt>\0
	 * so it must be computed as:
	 */
	size = strlen(name) + strlen(fmt) + 3;

	/* Allocate the new format */
	nfmt = malloc(size);
	if (!nfmt)
		return -1;

	/* Build the new format as "<name>: <fmt>".
	 *
	 * Note that nft string has the right size so
	 * we can safely not check the return value
	 */
	snprintf(nfmt, size, "%s: %s", name, fmt);
	
	/* Compute the output size */
	va_start(ap, fmt);
	ret = vsnprintf(NULL, 0, nfmt, ap);
	va_end(ap);
	if (ret < 0)
		goto free_nfmt;
	size = ret + 1; /* for '\0' */

	/* Allocate the output buffer */
	*str = malloc(size);
	if (*str == NULL) {
		ret = -1;
		goto free_nfmt;
	}

	/* Build the output string */
	va_start(ap, fmt);
	ret = vsnprintf(*str, size, nfmt, ap);
	va_end(ap);
	if (ret < 0)
		goto free_nfmt;

free_nfmt:
	free(nfmt);

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x12b3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, %rdi
callq 0x1050
addl $0x15, %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x1090
testq %rax, %rax
je 0x135f
movq %rax, %rbx
leaq 0xd5f(%rip), %rdx       # 0x203b
leaq 0xd35(%rip), %r8        # 0x2018
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1060
movabsq $0x3000000018, %r12     # imm = 0x3000000018
movq %rsp, %rcx
movq %r12, (%rcx)
leaq 0x110(%rsp), %r13
movq %r13, 0x8(%rcx)
leaq 0x20(%rsp), %rbp
movq %rbp, 0x10(%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1040
movl %eax, %r15d
testl %eax, %eax
js 0x136d
incl %r15d
movq %r15, %rdi
callq 0x1090
movq %rax, (%r14)
testq %rax, %rax
je 0x1367
movq %rsp, %rcx
movq %rbp, 0x10(%rcx)
movq %r13, 0x8(%rcx)
movq %r12, (%rcx)
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1040
movl %eax, %r15d
jmp 0x136d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x1375
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x1030
movl %r15d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gadget114514[P]fatfs-example/fmkfs.c
// Function: main
void main()
{
  char b[4096];
  FATFS fs;

  int fno = open("abc.dat", O_CREAT|O_SYNC|O_RDWR, S_IRUSR|S_IWUSR);
  printf("fno = %d\n", fno);
  int i = 0;
  char buf[512]={0};
  while (i < SECCOUNT) {
    //    printf("size = %ld\n", write(fno, buf, 512));
    write(fno, buf, 512);
    i++;
  }
  close(fno);
  fno = -1;
  //  f_mount(&fs, "", 0); 
  //  f_mkfs("", FM_FAT, 2*512, b, 4096);
  FCHK(f_mkfs("", FM_SFD|FM_FAT, 0, b, 4096));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1208, %rsp           # imm = 0x1208
leaq 0x3e41(%rip), %rdi      # 0x5004
movl $0x101042, %esi         # imm = 0x101042
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x10a0
movl %eax, %ebx
leaq 0x3e2f(%rip), %rdi      # 0x500c
movl %eax, %esi
xorl %eax, %eax
callq 0x1050
leaq -0x220(%rbp), %r14
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x80, %r15d
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
callq 0x1040
decl %r15d
jne 0x1202
movl %ebx, %edi
callq 0x1080
leaq 0x3df1(%rip), %rdi      # 0x5015
leaq -0x1220(%rbp), %rcx
movl $0x9, %esi
xorl %edx, %edx
movl $0x1000, %r8d           # imm = 0x1000
callq 0x3b00
cmpl $0x12, %eax
ja 0x1254
movl %eax, %ecx
leaq 0x418d(%rip), %rdx      # 0x53d8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmp 0x125b
leaq 0x4162(%rip), %rcx      # 0x53bd
leaq 0x3db4(%rip), %rdi      # 0x5016
leaq 0x3dc0(%rip), %rsi      # 0x5029
movl %eax, %edx
xorl %eax, %eax
callq 0x1050
addq $0x1208, %rsp           # imm = 0x1208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/exit_checker.c
// Function: ft_dellists
void	ft_dellists(t_list **list)
{
	t_list	*del;
	t_list	*lst;

	if (!list)
		return ;
	lst = *list;
	while (lst)
	{
		del = lst->next;
		free(lst->content);
		free(lst);
		lst = del;
	}
	*list = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x11e9
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x11dd
movq (%r14), %rdi
movq 0x8(%r14), %r15
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testq %r15, %r15
jne 0x11c1
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: check_existant
int		check_existant(char **av, int i)
{
	int		j;
	int		len;

	j = 1;
	while (j < i)
	{
		if (ft_strlen(av[j]) > ft_strlen(av[i]))
			len = ft_strlen(av[j]);
		else
			len = ft_strlen(av[i]);
		if (!ft_strncmp(av[j], av[i], len))
			return (1);
		j++;
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl $0x2, %esi
jl 0x12d9
movq %rdi, %r14
movl %esi, %r12d
leaq (%rdi,%r12,8), %r13
addq $0x8, %r14
decq %r12
movq (%r14), %rdi
callq 0x346a
movq %rax, %r15
movq (%r13), %rdi
callq 0x346a
cmpq %rax, %r15
movq %r13, %rax
cmovaq %r14, %rax
movq (%rax), %rdi
callq 0x346a
movq (%r14), %rdi
movq (%r13), %rsi
movslq %eax, %rdx
callq 0x3499
testl %eax, %eax
je 0x12d4
addq $0x8, %r14
decq %r12
jne 0x1290
jmp 0x12d9
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: parsing_ac
int		parsing_ac(char *av)
{
	int		i;
	int		minus;

	i = 0;
	minus = 0;
	while (av[i])
	{
		if (av[i] == '-')
			minus++;
		if (av[i] > '9' || av[i] < '0')
		{
			if (av[i] != '-' || minus > 1)
				return (-1);
		}
		i++;
	}
	return (0);
}

// Assembly:
xorl %ecx, %ecx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x12f5
testl %eax, %eax
jne 0x12f7
jmp 0x1313
incl %ecx
leal -0x3a(%rax), %edx
cmpb $-0xb, %dl
ja 0x130e
cmpl $0x2d, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x1313
cmpl $0x1, %ecx
jg 0x1313
incq %rdi
jmp 0x12e7
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: fill_list_a
t_list	*fill_list_a(char *av)
{
	t_list	*new;
	t_data	*new_data;

	if (!(new_data = malloc(sizeof(t_data))))
		return (NULL);
	new_data->value = ft_atoi(av);
	new_data->index = 0;
	new_data->keep = 0;
	new = ft_lstnew(new_data);
	return (new);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xc, %edi
callq 0x1090
testq %rax, %rax
je 0x1365
movq %rax, %rbx
movq %r14, %rdi
callq 0x3535
movl %eax, (%rbx)
movq $0x0, 0x4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3321
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_swap.c
// Function: ft_swap_a
void		ft_swap_a(t_lists *lists)
{
	t_list	*tmp_1;
	t_list	*tmp_2;
	t_list	*new_list;

	new_list = NULL;
	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp_1 = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp_1->next = NULL;
	tmp_2 = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp_2->next = NULL;
	new_list = lists->list_a;
	ft_lstadd_front(&new_list, tmp_1);
	ft_lstadd_front(&new_list, tmp_2);
	lists->list_a = new_list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x13cb
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x13cb
movq %rdi, %rbx
movq %r14, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r14), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movq %r15, %rdi
callq 0x3366
movq %r15, %rdi
movq %r14, %rsi
callq 0x3366
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_swap.c
// Function: ft_swap_b
void		ft_swap_b(t_lists *lists)
{
	t_list	*tmp_1;
	t_list	*tmp_2;
	t_list	*new_list;

	new_list = NULL;
	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp_1 = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp_1->next = NULL;
	tmp_2 = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp_2->next = NULL;
	new_list = lists->list_b;
	ft_lstadd_front(&new_list, tmp_1);
	ft_lstadd_front(&new_list, tmp_2);
	lists->list_b = new_list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x1434
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x1434
movq %rdi, %rbx
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movq %r15, %rdi
callq 0x3366
movq %r15, %rdi
movq %r14, %rsi
callq 0x3366
movq (%r15), %rax
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_rotate.c
// Function: ft_rotate_a
void	ft_rotate_a(t_lists *lists)
{
	t_list		*tmp;

	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp->next = NULL;
	ft_lstadd_back(&lists->list_a, tmp);
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x14b1
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x14b1
movq %rax, (%rdi)
movq $0x0, 0x8(%rsi)
jmp 0x3416
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_rotate.c
// Function: ft_rotate_b
void	ft_rotate_b(t_lists *lists)
{
	t_list		*tmp;

	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp->next = NULL;
	ft_lstadd_back(&lists->list_b, tmp);
}

// Assembly:
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x14d8
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x14d8
addq $0x8, %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rsi)
jmp 0x3416
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: del_last_a
void	del_last_a(t_lists *lists)
{
	int		i;
	t_list	*cursor;

	i = 0;
	cursor = lists->list_a;
	while (i < (ft_lstsize(lists->list_a) - 2))
	{
		i++;
		cursor = cursor->next;
	}
	cursor->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x33b1
cmpl $0x3, %eax
jl 0x155e
xorl %ebp, %ebp
incl %ebp
movq 0x8(%rbx), %rbx
movq (%r14), %rdi
callq 0x33b1
addl $-0x2, %eax
cmpl %eax, %ebp
jl 0x1549
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: del_last_b
void	del_last_b(t_lists *lists)
{
	int		i;
	t_list	*cursor;

	i = 0;
	cursor = lists->list_b;
	while (i < (ft_lstsize(lists->list_b) - 2))
	{
		i++;
		cursor = cursor->next;
	}
	cursor->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x33b1
cmpl $0x3, %eax
jl 0x159b
xorl %ebp, %ebp
incl %ebp
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %rdi
callq 0x33b1
addl $-0x2, %eax
cmpl %eax, %ebp
jl 0x1585
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: ft_rev_rotate_a
void	ft_rev_rotate_a(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp = ft_lstlast(lists->list_a);
	del_last_a(lists);
	ft_lstadd_front(&lists->list_a, tmp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x15e0
cmpq $0x0, 0x8(%rdi)
je 0x15e0
callq 0x33e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x1530
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3366
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: ft_rev_rotate_b
void	ft_rev_rotate_b(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp = ft_lstlast(lists->list_b);
	del_last_b(lists);
	ft_lstadd_front(&lists->list_b, tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1624
cmpq $0x0, 0x8(%rdi)
je 0x1624
leaq 0x8(%rbx), %r14
callq 0x33e6
movq %rax, %r15
movq %rbx, %rdi
callq 0x156b
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3366
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_a
void	ft_print_a(t_lists *lists)
{
	int		i;
	t_list	*cursor;
	t_data	*t;

	i = 0;
	cursor = lists->list_a;
	printf("\033[1;34mLIST A :\n");
	printf("___________________________________\n");
	printf("|   INDICE  |   NUMBER  |INDEX FINAL|\n");
	while (cursor)
	{
		t = cursor->content;
		printf("|%11d|%11d|%11d|\n", i, t->value, t->index);
		i++;
		cursor = cursor->next;
	}
	printf("___________________________________\033[0;m\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
leaq 0x29e9(%rip), %rdi      # 0x4033
callq 0x1040
leaq 0x29fd(%rip), %rdi      # 0x4053
callq 0x1040
leaq 0x2a15(%rip), %rdi      # 0x4077
callq 0x1040
testq %r14, %r14
je 0x1694
leaq 0x29ae(%rip), %rbx      # 0x4021
xorl %ebp, %ebp
movq (%r14), %rax
movl (%rax), %edx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
incl %ebp
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1675
leaq 0x2a02(%rip), %rdi      # 0x409d
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_b
void	ft_print_b(t_lists *lists)
{
	int		i;
	t_list	*cursor;
	t_data	*t;

	i = 0;
	cursor = lists->list_b;
	printf("\033[1;33mLIST B :\n");
	printf("___________________________________\n");
	printf("|   INDICE  |   NUMBER  |INDEX FINAL|\n");
	while (cursor)
	{
		t = cursor->content;
		printf("|%11d|%11d|%11d|\n", i, t->value, t->index);
		i++;
		cursor = cursor->next;
	}
	printf("___________________________________\033[0;m\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
leaq 0x2990(%rip), %rdi      # 0x4043
callq 0x1040
leaq 0x2994(%rip), %rdi      # 0x4053
callq 0x1040
leaq 0x29ac(%rip), %rdi      # 0x4077
callq 0x1040
testq %r14, %r14
je 0x16fd
leaq 0x2945(%rip), %rbx      # 0x4021
xorl %ebp, %ebp
movq (%r14), %rax
movl (%rax), %edx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
incl %ebp
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x16de
leaq 0x2999(%rip), %rdi      # 0x409d
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_both
void	ft_print_both(t_lists *lists)
{
	ft_print_a(lists);
	printf("-------------------------------------\n");
	ft_print_b(lists);
	printf("\033[1;31m=====================================\033[0;m\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x163c
leaq 0x29a9(%rip), %rdi      # 0x40c6
callq 0x1040
movq %rbx, %rdi
callq 0x16a4
leaq 0x29bb(%rip), %rdi      # 0x40ec
popq %rbx
jmp 0x1040
nop
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_command.c
// Function: use_commands
void	use_commands(t_list *commands, t_lists *lists)
{
	t_list	*cursor;

	cursor = commands->next;
	while (cursor)
	{
		swap_fct(lists, cursor);
		push_fct(lists, cursor);
		rotate_fct(lists, cursor);
		rev_rotate_fct(lists, cursor);
		cursor = cursor->next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x177d
movq %rsi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1934
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a02
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a6c
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1748
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/ft_command.c
// Function: ft_read_command
int		ft_read_command(t_list *commands)
{
	int		ret;
	char	*line;

	while ((ret = get_next_line(0, &line)) == 1)
	{
		if (!ft_strcmp(line, "sa") || !ft_strcmp(line, "sb")
		|| !ft_strcmp(line, "ss"))
			get_swap(commands, line);
		else if (!ft_strcmp(line, "pa") || !ft_strcmp(line, "pb"))
			get_push(commands, line);
		else if (!ft_strcmp(line, "ra") || !ft_strcmp(line, "rb")
		|| !ft_strcmp(line, "rr"))
			get_rotate(commands, line);
		else if (!ft_strcmp(line, "rra") ||
		!ft_strcmp(line, "rrb") || !ft_strcmp(line, "rrr"))
			get_rev_rotate(commands, line);
		else
		{
			get_next_line(-42, &line);
			free(line);
			return (-1);
		}
		free(line);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1da1
cmpl $0x1, %eax
jne 0x1923
leaq 0x296f(%rip), %r14      # 0x411e
movq %rsp, %r15
leaq 0x2968(%rip), %r12      # 0x4121
leaq 0x2964(%rip), %r13      # 0x4124
xorl %ebp, %ebp
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x36ec
testl %eax, %eax
je 0x18c0
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x36ec
testl %eax, %eax
je 0x18c0
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x36ec
testl %eax, %eax
je 0x18c0
movq (%rsp), %rdi
leaq 0x291e(%rip), %rsi      # 0x4127
callq 0x36ec
testl %eax, %eax
je 0x18ea
movq (%rsp), %rdi
leaq 0x2909(%rip), %rsi      # 0x412a
callq 0x36ec
testl %eax, %eax
je 0x18ea
movq (%rsp), %rdi
leaq 0x28f5(%rip), %rsi      # 0x412e
callq 0x36ec
testl %eax, %eax
je 0x18f8
movq (%rsp), %rdi
leaq 0x28e1(%rip), %rsi      # 0x4132
callq 0x36ec
testl %eax, %eax
je 0x18f8
movq (%rsp), %rdi
leaq 0x28cd(%rip), %rsi      # 0x4136
callq 0x36ec
testl %eax, %eax
je 0x18f8
movq (%rsp), %rdi
leaq 0x28ac(%rip), %rsi      # 0x412d
callq 0x36ec
testl %eax, %eax
je 0x18b2
movq (%rsp), %rdi
leaq 0x289c(%rip), %rsi      # 0x4131
callq 0x36ec
testl %eax, %eax
je 0x18b2
movq (%rsp), %rdi
leaq 0x288c(%rip), %rsi      # 0x4135
callq 0x36ec
testl %eax, %eax
jne 0x1906
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1c62
jmp 0x18cc
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1b82
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
movq %r15, %rsi
callq 0x1da1
cmpl $0x1, %eax
je 0x17c2
jmp 0x1923
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1b28
jmp 0x18cc
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1bf2
jmp 0x18cc
movq %rsp, %rbx
movl $0xffffffd6, %edi       # imm = 0xFFFFFFD6
movq %rbx, %rsi
callq 0x1da1
movq (%rbx), %rdi
callq 0x1030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: swap_fct
void	swap_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "sa"))
		ft_swap_a(lists);
	else if (!ft_strcmp(commands->content, "sb"))
		ft_swap_b(lists);
	else if (!ft_strcmp(commands->content, "ss"))
		ft_swap_ss(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x27d6(%rip), %rsi      # 0x411e
callq 0x36ec
testl %eax, %eax
je 0x197f
movq (%r14), %rdi
leaq 0x27c6(%rip), %rsi      # 0x4121
callq 0x36ec
testl %eax, %eax
je 0x198e
movq (%r14), %rdi
leaq 0x27b6(%rip), %rsi      # 0x4124
callq 0x36ec
testl %eax, %eax
je 0x199d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1370
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13d5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x143e
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: push_fct
void	push_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "pa"))
		ft_push_a(lists);
	else if (!ft_strcmp(commands->content, "pb"))
		ft_push_b(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2767(%rip), %rsi      # 0x4127
callq 0x36ec
testl %eax, %eax
je 0x19e4
movq (%r14), %rdi
leaq 0x2757(%rip), %rsi      # 0x412a
callq 0x36ec
testl %eax, %eax
je 0x19f3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1450
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x146f
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: rotate_fct
void	rotate_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "ra"))
		ft_rotate_a(lists);
	if (!ft_strcmp(commands->content, "rb"))
		ft_rotate_b(lists);
	if (!ft_strcmp(commands->content, "rr"))
		ft_rotate_rr(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2718(%rip), %rsi      # 0x412e
callq 0x36ec
testl %eax, %eax
jne 0x1a27
movq %rbx, %rdi
callq 0x1490
movq (%r14), %rdi
leaq 0x2701(%rip), %rsi      # 0x4132
callq 0x36ec
testl %eax, %eax
jne 0x1a42
movq %rbx, %rdi
callq 0x14b2
movq (%r14), %rdi
leaq 0x26ea(%rip), %rsi      # 0x4136
callq 0x36ec
testl %eax, %eax
je 0x1a5d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14d9
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: rev_rotate_fct
void	rev_rotate_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "rra"))
		ft_rev_rotate_a(lists);
	if (!ft_strcmp(commands->content, "rrb"))
		ft_rev_rotate_b(lists);
	if (!ft_strcmp(commands->content, "rrr"))
		ft_rev_rotate_rrr(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x26ad(%rip), %rsi      # 0x412d
callq 0x36ec
testl %eax, %eax
jne 0x1a91
movq %rbx, %rdi
callq 0x15a8
movq (%r14), %rdi
leaq 0x2696(%rip), %rsi      # 0x4131
callq 0x36ec
testl %eax, %eax
jne 0x1aac
movq %rbx, %rdi
callq 0x15e8
movq (%r14), %rdi
leaq 0x267f(%rip), %rsi      # 0x4135
callq 0x36ec
testl %eax, %eax
je 0x1ac7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x162a
nop
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/checker/check_sort.c
// Function: check_sort
void		check_sort(int ac, t_lists *lists)
{
	int		value;
	t_list	*cursor;
	t_data	*this;
	t_data	*the_next;

	cursor = lists->list_a;
	if (ft_lstsize(cursor) != (ac - 1))
	{
		printf("\033[1;31mKO\n\033[0;m");
		return ;
	}
	while (cursor->next)
	{
		this = cursor->content;
		value = this->value;
		the_next = cursor->next->content;
		if (value > the_next->value)
		{
			printf("\033[1;31mKO\n\033[0;m");
			return ;
		}
		cursor = cursor->next;
	}
	printf("\033[1;32mOK\n\033[0;m");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movq (%rsi), %rbx
movq %rbx, %rdi
callq 0x33b1
decl %ebp
leaq 0x2648(%rip), %rdi      # 0x4139
cmpl %ebp, %eax
jne 0x1b19
leaq 0x264d(%rip), %rax      # 0x4149
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1b16
movq (%rbx), %rdx
movl (%rdx), %edx
movq (%rcx), %rsi
movq %rcx, %rbx
cmpl (%rsi), %edx
jle 0x1afc
jmp 0x1b19
movq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: append_first_lines
char	*append_first_lines(char *str, char **line, int i)
{
	char *tmp;

	str[i] = '\0';
	*line = ft_strdup(str);
	tmp = ft_strdup(str + (i + 1));
	free(str);
	str = tmp;
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rax
leaq (%rdi,%rax), %r15
incq %r15
movb $0x0, -0x1(%r15)
callq 0x366e
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x366e
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: append_next_lines
char	*append_next_lines(char *str, char **line, int i, int output)
{
	if (output == 0 && i != -1)
	{
		append_first_lines(str, line, i);
		return (str);
	}
	else if (output == 0)
	{
		*line = ft_strdup(str);
		free(str);
		str = NULL;
		return (str);
	}
	free(str);
	str = NULL;
	return (str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
setne %al
cmpl $-0x1, %edx
sete %sil
orb %al, %sil
jne 0x1d3a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1cd4
jmp 0x1d53
testl %ecx, %ecx
jne 0x1d49
movq %rbx, %rdi
callq 0x366e
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: get_next_line
int		get_next_line(int fd, char **line)
{
	static char		*str = NULL;
	char			buffer[BUFFER_SIZE + 1];
	int				output;
	int				i;

	i = 0;
	if (fd < 0 && str)
	{
		free(str);
		return (-1);
	}
	while (((output = read(fd, buffer, BUFFER_SIZE)) && output > 0) || i != -1)
	{
		buffer[output] = '\0';
		str = ft_join(str, buffer);
		i = check_line(str);
		if (i >= 0)
		{
			str = append_first_lines(str, line, i);
			return (1);
		}
		if (is_output_null(output, str) == 0)
			return (0);
	}
	return (read_finished(str, line, output, i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebp
testl %edi, %edi
sets %al
movq 0x52b5(%rip), %rdi      # 0x7070
testq %rdi, %rdi
setne %cl
testb %cl, %al
je 0x1dd4
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1e7f
movq %rsi, %rbx
xorl %r12d, %r12d
movq %rsp, %r14
movl $0x20, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1070
movq %rax, %r15
testl %r15d, %r15d
setle %al
cmpl $-0x1, %r12d
sete %cl
testb %al, %cl
jne 0x1e41
movslq %r15d, %rax
movb $0x0, (%rsp,%rax)
movq 0x5262(%rip), %rdi      # 0x7070
movq %r14, %rsi
callq 0x1e8c
movq %rax, 0x5253(%rip)      # 0x7070
movq %rax, %rdi
callq 0x1f41
movl %eax, %r12d
testl %eax, %eax
jns 0x1e61
testl %r15d, %r15d
jne 0x1ddd
movq 0x5238(%rip), %rdi      # 0x7070
callq 0x1030
xorl %eax, %eax
jmp 0x1e7f
movq 0x5228(%rip), %rdi      # 0x7070
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r15d, %ecx
callq 0x1d12
xorl %eax, %eax
negl %r15d
sbbl %eax, %eax
jmp 0x1e7f
movq 0x5208(%rip), %rdi      # 0x7070
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1cd4
movq %rax, 0x51f6(%rip)      # 0x7070
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/gnl/get_next_line_utils.c
// Function: ft_join
char	*ft_join(char *s1, char *s2)
{
	size_t		i;
	size_t		j;
	size_t		len1;
	char		*str;

	if (s1 == NULL)
		len1 = 0;
	else
		len1 = ft_strlen(s1);
	if (!(str = malloc(sizeof(char) * (len1 + ft_strlen(s2) + 1))))
		return (NULL);
	i = 0;
	j = 0;
	while (i < len1)
	{
		str[i] = s1[i];
		i++;
	}
	while (j < ft_strlen(s2))
		str[i++] = s2[j++];
	str[i] = '\0';
	free(s1);
	return (str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1eaf
movq %rbx, %rdi
callq 0x346a
movq %rax, %r15
jmp 0x1eb2
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x346a
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1090
testq %rax, %rax
je 0x1ee6
movq %rax, %r12
testq %r15, %r15
je 0x1eeb
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1080
movq %r15, %r13
jmp 0x1eee
xorl %r12d, %r12d
jmp 0x1f2f
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x346a
testq %rax, %rax
je 0x1f22
movq %r12, %r13
addq %r15, %r13
xorl %ebp, %ebp
movb (%r14,%rbp), %al
movb %al, (%r13,%rbp)
incq %rbp
movq %r14, %rdi
callq 0x346a
cmpq %rax, %rbp
jb 0x1f03
addq %rbp, %r15
movq %r15, %r13
movb $0x0, (%r12,%r13)
movq %rbx, %rdi
callq 0x1030
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/get_index.c
// Function: get_index
void	get_index(t_list *l_a)
{
	t_list	*cursor;
	t_data	*this;
	int		index;

	cursor = l_a;
	while (cursor)
	{
		this = cursor->content;
		index = comp_value(l_a, this);
		this->index = index;
		cursor = cursor->next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x1fb6
movq %rdi, %rax
movq (%rax), %rcx
movl (%rcx), %esi
xorl %edx, %edx
movq %rdi, %r8
movq (%r8), %r9
xorl %r10d, %r10d
cmpl (%r9), %esi
movq 0x8(%r8), %r8
setg %r10b
addl %r10d, %edx
testq %r8, %r8
jne 0x1f91
movl %edx, 0x4(%rcx)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1f87
retq
nop
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: first_in_chunk
int		first_in_chunk(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;
	int		ret;

	cursor = la;
	this = cursor->content;
	ret = 0;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			return (ret);
		ret++;
		cursor = cursor->next;
	}
	return (-1);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x2045
xorl %ecx, %ecx
movq (%rdx), %r8
movl 0x4(%r8), %r8d
cmpl %edi, %r8d
setge %r9b
cmpl %esi, %r8d
setle %r8b
testb %r8b, %r9b
jne 0x2046
incl %ecx
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0x2020
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: last_in_chunk
int		last_in_chunk(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;
	int		index;

	cursor = la;
	this = cursor->content;
	index = -1;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			index = this->index;
		cursor = cursor->next;
	}
	if (index != -1)
		return (how_many_rotate(la, index) - 1);
	return (-1);
}

// Assembly:
pushq %rax
movl %esi, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x207f
movq %rdx, %r8
movq (%r8), %r9
movq 0x8(%r8), %r8
movl 0x4(%r9), %r9d
cmpl %ecx, %r9d
movl %r9d, %r10d
cmovgl %esi, %r10d
cmpl %edi, %r9d
cmovgel %r10d, %esi
testq %r8, %r8
jne 0x205e
cmpl $-0x1, %esi
je 0x208e
movq %rdx, %rdi
callq 0x31b4
decl %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: fill_b_per_chunk
void	fill_b_per_chunk(t_lists *l, int chunk1, int chunk2)
{
	int ra_nb;
	int rra_nb;
	int rb_nb;

	while (first_in_chunk(chunk1, chunk2, l->list_a) != -1)
	{
		ra_nb = first_in_chunk(chunk1, chunk2, l->list_a);
		rra_nb = ft_lstsize(l->list_a) -
		last_in_chunk(chunk1, chunk2, l->list_a);
		if (ft_lstsize(l->list_b) > 1)
			rb_nb = how_many_rotate(l->list_b,
			chose_index_to_push(l, chunk1, chunk2)) - 1;
		ra_or_rra_hundred(l, ra_nb, rra_nb, rb_nb);
		write_pb(l);
		if (chose_index_to_push(l, chunk1, chunk2) == -1)
			write_rb(l);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
sete %al
je 0x219a
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %rcx
movq (%rcx), %rdx
movl 0x4(%rdx), %edx
cmpl %ebp, %edx
setge %sil
cmpl %ebx, %edx
setle %dl
testb %dl, %sil
jne 0x20d8
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x20b4
jmp 0x219a
testb $0x1, %al
jne 0x2102
xorl %eax, %eax
movq %rdi, %rcx
movq (%rcx), %rdx
movl 0x4(%rdx), %edx
cmpl %ebp, %edx
setge %sil
cmpl %ebx, %edx
setle %dl
testb %dl, %sil
jne 0x210c
incl %eax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x20e1
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x2110
movl %eax, 0x4(%rsp)
callq 0x33b1
movl %eax, %r13d
movq (%r14), %rdx
movl %ebp, %edi
movl %ebx, %esi
callq 0x2049
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x33b1
cmpl $0x2, %eax
jl 0x2155
movq 0x8(%r14), %r12
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x24dc
movq %r12, %rdi
movl %eax, %esi
callq 0x31b4
movl %eax, %r12d
decl %r12d
subl %r15d, %r13d
movq %r14, %rdi
movl 0x4(%rsp), %esi
movl %r13d, %edx
movl %r12d, %ecx
callq 0x30f3
movq %r14, %rdi
callq 0x2220
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x24dc
cmpl $-0x1, %eax
jne 0x218b
movq %r14, %rdi
callq 0x22b5
movq (%r14), %rdi
testq %rdi, %rdi
sete %al
jne 0x20b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)