LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_16_rxs_m_xs_16_boundedrand_r
inline uint16_t
pcg_unique_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng,
                                        uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_unique_16_rxs_m_xs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzwl %ax, %eax
movzwl -0xa(%rbp), %ecx
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1f79
movzwl -0xe(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cltd
idivl %ecx
movw %dx, %ax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1f4c
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_16_rxs_m_xs_16_boundedrand_r
inline uint16_t
pcg_setseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_setseq_16* rng,
                                        uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_setseq_16_rxs_m_xs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movzwl %ax, %eax
movzwl -0xa(%rbp), %ecx
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f80
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jl 0x2009
movzwl -0xe(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cltd
idivl %ecx
movw %dx, %ax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1fdc
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movw %dx, %cx
movw %si, %dx
movw %di, %si
movw %si, -0x2(%rbp)
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movw $0x1, -0xa(%rbp)
movw $0x0, -0xc(%rbp)
movzwl -0x4(%rbp), %eax
cmpl $0x0, %eax
jle 0x2cb8
movzwl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2c85
movzwl -0x6(%rbp), %ecx
movzwl -0xa(%rbp), %eax
imull %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xc(%rbp), %eax
movzwl -0x6(%rbp), %ecx
imull %ecx, %eax
movzwl -0x8(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0x6(%rbp), %eax
addl $0x1, %eax
movzwl -0x8(%rbp), %ecx
imull %ecx, %eax
movw %ax, -0x8(%rbp)
movzwl -0x6(%rbp), %ecx
movzwl -0x6(%rbp), %eax
imull %ecx, %eax
movw %ax, -0x6(%rbp)
movzwl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, -0x4(%rbp)
jmp 0x2c4c
movzwl -0xa(%rbp), %eax
movzwl -0x2(%rbp), %ecx
imull %ecx, %eax
movzwl -0xc(%rbp), %ecx
addl %ecx, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/split_fastq.c
// Function: parse_fastq_read
static int parse_fastq_read(ReadSeq *read, gzFile f) {
  size_t qual_len;

  read->status = FASTQ_OK;

  read_fastq_lines(read, f);
  if(read->status != FASTQ_OK) {
    return read->status;
  }

  
  /* check_header(read); */
  /* if(read->status != FASTQ_OK) { */
  /*   return read->status; */
  /* } */


  /* third line should start with '+' separator */
  if(read->line3[0] != '+') {
    my_warn("%s:%d: third line does not start with '+'", 
	  __FILE__, __LINE__);
    read->status = FASTQ_ERR;
    return read->status;
  }
   
  /* check length of read and quality */
  read->read_len = strlen(read->line2);
  qual_len = strlen(read->line4);
  
  if(read->read_len < 1) {
    my_warn("%s:%d: read has no bases\n", __FILE__, __LINE__);
    return read->status;
  }

  /* next line should be quality scores */
  if(read->read_len != qual_len) {
    my_warn("%s:%d: read len (%ld) does not match quality score len (%ld)",
	  __FILE__, __LINE__, read->read_len, qual_len);
    read->status = FASTQ_ERR;
    return read->status;
  }

  check_seq(read);
  check_qual(read);

  return read->status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x1420(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c80
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1420(%rax)
je 0x1a0a
movq -0x10(%rbp), %rax
movl 0x1420(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b2f
movq -0x10(%rbp), %rax
movsbl 0xc1e(%rax), %eax
cmpl $0x2b, %eax
je 0x1a54
leaq 0x372b(%rip), %rdi      # 0x514c
leaq 0x363e(%rip), %rsi      # 0x5066
movl $0x14b, %edx            # imm = 0x14B
movb $0x0, %al
callq 0x3fd0
movq -0x10(%rbp), %rax
movl $0x1, 0x1420(%rax)
movq -0x10(%rbp), %rax
movl 0x1420(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b2f
movq -0x10(%rbp), %rdi
addq $0x81e, %rdi            # imm = 0x81E
callq 0x1110
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x418(%rax)
movq -0x10(%rbp), %rdi
addq $0x101e, %rdi           # imm = 0x101E
callq 0x1110
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x418(%rax)
jge 0x1aba
leaq 0x36de(%rip), %rdi      # 0x5176
leaq 0x35c7(%rip), %rsi      # 0x5066
movl $0x155, %edx            # imm = 0x155
movb $0x0, %al
callq 0x3fd0
movq -0x10(%rbp), %rax
movl 0x1420(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b2f
movq -0x10(%rbp), %rax
movslq 0x418(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x1b10
movq -0x10(%rbp), %rax
movl 0x418(%rax), %ecx
movq -0x20(%rbp), %r8
leaq 0x36b0(%rip), %rdi      # 0x5190
leaq 0x357f(%rip), %rsi      # 0x5066
movl $0x15c, %edx            # imm = 0x15C
movb $0x0, %al
callq 0x3fd0
movq -0x10(%rbp), %rax
movl $0x1, 0x1420(%rax)
movq -0x10(%rbp), %rax
movl 0x1420(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b2f
movq -0x10(%rbp), %rdi
callq 0x1f60
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x1420(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/split_fastq.c
// Function: report_qual_type
static void report_qual_type(char min_qual, char max_qual) {
  fprintf(stderr, "\n");
  fprintf(stderr, "guessing quality format:\n");

  if((min_qual == -1) || (max_qual == -1)) {
    fprintf(stderr, "  no valid quality scores to guess quality type from\n");
  }

  fprintf(stderr, "  min_qual:%c, max_qual:%c\n", min_qual, max_qual);
  if(min_qual < MIN_QUAL_SOLEXA) {
    fprintf(stderr, "  quality vals appear to be Sanger / Illum 1.8+ format"
	    " (Phred+33)\n");
    
    if(max_qual >= 'h') {
      my_warn("%s:%d: quality vals may be mix of Phred+33 and Phred+64\n"
	      "         You should probably fix this.", __FILE__, __LINE__);
    }
  } else {
    if(min_qual < MIN_QUAL_ILLUM_1_3) {
      my_warn("%s:%d: quality vals appear to be OLD solexa format, "
	      "may need to convert prior to processing.\n", __FILE__, __LINE__);
    }
    else if(min_qual < MIN_QUAL_ILLUM_1_5) {
      fprintf(stderr, "  quality vals appear to be Illumina 1.3+ format "
	      "(Phred+64)\n  should probably use -I flag for bwa aln "
	      "(relevant only if using -q argument)\n");
    }
    else {
      fprintf(stderr, "  quality vals appear to be Illumina 1.5+ format "
	      "(Phred+64)\n  should probably use -I flag for bwa aln "
	      "(relevant only if using -q argument)\n");
      
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq 0x649d(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x375d(%rip), %rsi      # 0x52c2
movb $0x0, %al
callq 0x1170
movq 0x6485(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3853(%rip), %rsi      # 0x53d0
movb $0x0, %al
callq 0x1170
movsbl -0x1(%rbp), %eax
cmpl $-0x1, %eax
je 0x1b96
movsbl -0x2(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1bae
movq 0x645b(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3843(%rip), %rsi      # 0x53ea
movb $0x0, %al
callq 0x1170
movq 0x6443(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movsbl -0x1(%rbp), %edx
movsbl -0x2(%rbp), %ecx
leaq 0x3859(%rip), %rsi      # 0x5420
movb $0x0, %al
callq 0x1170
movsbl -0x1(%rbp), %eax
cmpl $0x3b, %eax
jge 0x1c14
movq 0x641a(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3854(%rip), %rsi      # 0x543c
movb $0x0, %al
callq 0x1170
movsbl -0x2(%rbp), %eax
cmpl $0x68, %eax
jl 0x1c12
leaq 0x3880(%rip), %rdi      # 0x547f
leaq 0x3460(%rip), %rsi      # 0x5066
movl $0x178, %edx            # imm = 0x178
movb $0x0, %al
callq 0x3fd0
jmp 0x1c78
movsbl -0x1(%rbp), %eax
cmpl $0x40, %eax
jge 0x1c39
leaq 0x38ba(%rip), %rdi      # 0x54de
leaq 0x343b(%rip), %rsi      # 0x5066
movl $0x17d, %edx            # imm = 0x17D
movb $0x0, %al
callq 0x3fd0
jmp 0x1c76
movsbl -0x1(%rbp), %eax
cmpl $0x42, %eax
jge 0x1c5c
movq 0x63af(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x38e9(%rip), %rsi      # 0x553c
movb $0x0, %al
callq 0x1170
jmp 0x1c74
movq 0x6395(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x395b(%rip), %rsi      # 0x55c8
movb $0x0, %al
callq 0x1170
jmp 0x1c76
jmp 0x1c78
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/split_fastq.c
// Function: check_seq
static int check_seq(ReadSeq *read) {
  int i, j;
  char c;
  int err;
  /* string of valid nucleotide identifiers, including ambiguity codes */
  static const char *valid_nucs = "ATCGNatcgnMRWSYKmrwsyk";

  err = FALSE;
  for(i = 0; i < read->read_len; i++) {
    c = read->line2[i];

    j = 0;
    while(c != valid_nucs[j]) {
      if(valid_nucs[j] == '\0') {
	my_warn("%s:%d: read contains invalid base '%c'", 
		__FILE__, __LINE__, c);
	err = TRUE;
	break;
      }
      j++;
    }

    if(err) {
      read->status = FASTQ_ERR;
      break;
    }
  }

  return read->status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x418(%rcx), %eax
jge 0x2029
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb 0x81e(%rax,%rcx), %al
movb %al, -0x11(%rbp)
movl $0x0, -0x10(%rbp)
movsbl -0x11(%rbp), %eax
movq 0x61af(%rip), %rcx      # 0x8160
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2003
movq 0x619c(%rip), %rax      # 0x8160
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1ff8
movsbl -0x11(%rbp), %ecx
leaq 0x3394(%rip), %rdi      # 0x5370
leaq 0x3083(%rip), %rsi      # 0x5066
movl $0xf8, %edx
movb $0x0, %al
callq 0x3fd0
movl $0x1, -0x18(%rbp)
jmp 0x2003
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fa6
cmpl $0x0, -0x18(%rbp)
je 0x2019
movq -0x8(%rbp), %rax
movl $0x1, 0x1420(%rax)
jmp 0x2029
jmp 0x201b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f7a
movq -0x8(%rbp), %rax
movl 0x1420(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/split_fastq.c
// Function: check_qual
static int check_qual(ReadSeq *read) {
  int i;
  char c;

  read->min_qual = -1;
  read->max_qual = -1;

  for(i = 0; i < read->read_len; i++) {
    c = read->line4[i];

    if(read->min_qual == -1) {
      read->min_qual = c;
      read->max_qual = c;
    } else {
      if(c < read->min_qual) {
	read->min_qual = c;
      }
      if(c > read->max_qual) {
	read->max_qual = c;
      }
    }
  }

  if(read->min_qual < MIN_QUAL) {
    my_warn("%s:%d: read has invalid quality value with ascii code %d",
	    __FILE__, __LINE__, read->min_qual);
    read->status = FASTQ_ERR;
  }
  if(read->max_qual > MAX_QUAL) {
    my_warn("%s:%d: read has invalid quality value with ascii code %d",
	    __FILE__, __LINE__, read->max_qual);
    read->status = FASTQ_ERR;
  }

  return read->status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $-0x1, 0x41c(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x41d(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x418(%rcx), %eax
jge 0x210c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb 0x101e(%rax,%rcx), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x41c(%rax), %eax
cmpl $-0x1, %eax
jne 0x20ba
movb -0xd(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41c(%rax)
movb -0xd(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41d(%rax)
jmp 0x20fc
movsbl -0xd(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl 0x41c(%rcx), %ecx
cmpl %ecx, %eax
jge 0x20da
movb -0xd(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41c(%rax)
movsbl -0xd(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl 0x41d(%rcx), %ecx
cmpl %ecx, %eax
jle 0x20fa
movb -0xd(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41d(%rax)
jmp 0x20fc
jmp 0x20fe
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2069
movq -0x8(%rbp), %rax
movsbl 0x41c(%rax), %eax
cmpl $0x21, %eax
jge 0x214f
movq -0x8(%rbp), %rax
movsbl 0x41c(%rax), %ecx
leaq 0x3269(%rip), %rdi      # 0x5397
leaq 0x2f31(%rip), %rsi      # 0x5066
movl $0x126, %edx            # imm = 0x126
movb $0x0, %al
callq 0x3fd0
movq -0x8(%rbp), %rax
movl $0x1, 0x1420(%rax)
movq -0x8(%rbp), %rax
movsbl 0x41d(%rax), %eax
cmpl $0x7e, %eax
jle 0x2192
movq -0x8(%rbp), %rax
movsbl 0x41d(%rax), %ecx
leaq 0x3226(%rip), %rdi      # 0x5397
leaq 0x2eee(%rip), %rsi      # 0x5066
movl $0x12b, %edx            # imm = 0x12B
movb $0x0, %al
callq 0x3fd0
movq -0x8(%rbp), %rax
movl $0x1, 0x1420(%rax)
movq -0x8(%rbp), %rax
movl 0x1420(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/split_fastq.c
// Function: seek_next_header
static void seek_next_header(gzFile f) {
  char c1, c2;
  size_t n;

  c1 = '\n';
  c2 = gzgetc(f);

  /* search for the next line that starts with '@' */
  n = 0;
  while(c2 != -1) {
    if((c1 == '\n') && (c2 == '@')) {
      /* backup one byte to put '@' back on file stream */
      gzseek(f, -1, SEEK_CUR);
      fprintf(stderr, "skipped %ld bytes to find next fastq header line\n", n);
      return;
    }
    c1 = c2;
    c2 = gzgetc(f);
    n++;
  }
  fprintf(stderr, "skipped %ld bytes at end of file\n", n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0xa, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x21ff
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x220b
movq -0x8(%rbp), %rdi
callq 0x10f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $-0x1, %eax
je 0x22d6
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x226e
movsbl -0xa(%rbp), %eax
cmpl $0x40, %eax
jne 0x226e
movq -0x8(%rbp), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x1120
movq 0x5da4(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2fc0(%rip), %rsi      # 0x5222
movb $0x0, %al
callq 0x1170
jmp 0x22f2
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x22b3
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x22bf
movq -0x8(%rbp), %rdi
callq 0x10f0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2219
movq 0x5d1b(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2f69(%rip), %rsi      # 0x5254
movb $0x0, %al
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x12c1
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1060
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jg 0x12a4
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1298
movq $0x0, -0x30(%rbp)
jmp 0x12a2
movq $-0x1, -0x8(%rbp)
jmp 0x12c9
jmp 0x12a4
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1263
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x1040
leaq -0x4c(%rip), %rax       # 0x1180
movq %rax, -0xa0(%rbp)
movl $0xa, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1050
callq 0x1070
movl %eax, -0xa4(%rbp)
movl $0x0, -0xa8(%rbp)
cmpl $0xa, -0xa8(%rbp)
jge 0x1227
movl -0xa4(%rbp), %edi
movl $0xa, %esi
callq 0x1060
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0x11fd
movl 0x2e27(%rip), %esi      # 0x4054
leaq 0xdd0(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x11e4
movq 0x2e35(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe30(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1256
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
leaq 0xe21(%rip), %rdx       # 0x2018
movl $0xa, %ecx
movl $0x78, %r8d
movb $0x0, %al
callq 0x1260
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1233
movq 0x2ddf(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe08(%rip), %rsi       # 0x202b
movb $0x0, %al
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1256
movq -0x18(%rbp), %rdi
movq 0x2d9a(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1070
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x1470, %rsp           # imm = 0x1470
leaq 0x5ea2(%rip), %rdi      # 0x7054
movl $0x101042, %esi         # imm = 0x101042
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x1090
movl %eax, -0x125c(%rbp)
movl -0x125c(%rbp), %esi
leaq 0x5e86(%rip), %rdi      # 0x705c
movb $0x0, %al
callq 0x1040
movl $0x0, -0x1260(%rbp)
leaq -0x1460(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x1060
cmpl $0x80, -0x1260(%rbp)
jge 0x122e
movl -0x125c(%rbp), %edi
leaq -0x1460(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x1030
movl -0x1260(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1260(%rbp)
jmp 0x11fa
movl -0x125c(%rbp), %edi
callq 0x1070
movl $0xffffffff, -0x125c(%rbp) # imm = 0xFFFFFFFF
leaq -0x1000(%rbp), %rcx
leaq 0x5e14(%rip), %rdi      # 0x7065
movl $0x9, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x1000, %r8d           # imm = 0x1000
callq 0x53c0
movl %eax, -0x1464(%rbp)
movl -0x1464(%rbp), %eax
movl %eax, -0x1468(%rbp)
movl -0x1464(%rbp), %edi
callq 0x12b0
movl -0x1468(%rbp), %edx
movq %rax, %rcx
leaq 0x5dd4(%rip), %rdi      # 0x7066
leaq 0x5de0(%rip), %rsi      # 0x7079
movb $0x0, %al
callq 0x1040
addq $0x1470, %rsp           # imm = 0x1470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11a5
jmp 0x11ed
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11e2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x11b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x13ab
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4543
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4543
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0x135a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4543
movl %eax, -0x1c(%rbp)
jmp 0x136e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4543
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x4572
cmpl $0x0, %eax
jne 0x139d
movl $0x1, -0x4(%rbp)
jmp 0x13b2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1306
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x144d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x13fe
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x1420
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jge 0x1442
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x1437
cmpl $0x1, -0x18(%rbp)
jle 0x1440
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1454
jmp 0x1442
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13d6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: is_an_int
int		is_an_int(char *av)
{
	long int		value;

	value = ft_atoi(av);
	if (value > 2147483647 || value < -2147483648)
		return (-1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x460e
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jg 0x148d
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jge 0x1496
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x149d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xc, %edi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x14da
movq $0x0, -0x8(%rbp)
jmp 0x1516
movq -0x10(%rbp), %rdi
callq 0x460e
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x154c
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1551
jmp 0x15d3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x443f
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x443f
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x160e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1613
jmp 0x169d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x443f
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x443f
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/ft_push.c
// Function: ft_push_a
void	ft_push_a(t_lists *lists)
{
	t_list	*tmp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16f9
jmp 0x1732
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x443f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/ft_push.c
// Function: ft_push_b
void	ft_push_b(t_lists *lists)
{
	t_list	*tmp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1758
jmp 0x1792
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x443f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x17c4
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x17c6
jmp 0x17fc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x44ef
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1836
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1838
jmp 0x1875
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x44ef
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x1903
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18ce
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x1975
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x193f
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x19b4
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x19b6
jmp 0x19dc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x44bf
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x443f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a16
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a18
jmp 0x1a43
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x44bf
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1920
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x443f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x357c(%rip), %rdi      # 0x5021
movb $0x0, %al
callq 0x1050
leaq 0x357f(%rip), %rdi      # 0x5032
movb $0x0, %al
callq 0x1050
leaq 0x3596(%rip), %rdi      # 0x5057
movb $0x0, %al
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x1b0f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x358d(%rip), %rdi      # 0x507e
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ac8
leaq 0x357a(%rip), %rdi      # 0x5090
movb $0x0, %al
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x3564(%rip), %rdi      # 0x50ba
movb $0x0, %al
callq 0x1050
leaq 0x34ce(%rip), %rdi      # 0x5032
movb $0x0, %al
callq 0x1050
leaq 0x34e5(%rip), %rdi      # 0x5057
movb $0x0, %al
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x1bc0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x34dc(%rip), %rdi      # 0x507e
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1b79
leaq 0x34c9(%rip), %rdi      # 0x5090
movb $0x0, %al
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a80
leaq 0x34cf(%rip), %rdi      # 0x50cb
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1b30
leaq 0x34df(%rip), %rdi      # 0x50f2
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c85
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1eb0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f90
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c3c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
callq 0x2580
movl %eax, -0x14(%rbp)
cmpl $0x1, %eax
jne 0x1e10
movq -0x20(%rbp), %rdi
leaq 0x3467(%rip), %rsi      # 0x5125
callq 0x47c5
cmpl $0x0, %eax
je 0x1cf2
movq -0x20(%rbp), %rdi
leaq 0x3455(%rip), %rsi      # 0x5128
callq 0x47c5
cmpl $0x0, %eax
je 0x1cf2
movq -0x20(%rbp), %rdi
leaq 0x3443(%rip), %rsi      # 0x512b
callq 0x47c5
cmpl $0x0, %eax
jne 0x1d04
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2150
jmp 0x1e02
movq -0x20(%rbp), %rdi
leaq 0x341f(%rip), %rsi      # 0x512e
callq 0x47c5
cmpl $0x0, %eax
je 0x1d2e
movq -0x20(%rbp), %rdi
leaq 0x340d(%rip), %rsi      # 0x5131
callq 0x47c5
cmpl $0x0, %eax
jne 0x1d40
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20c0
jmp 0x1e00
movq -0x20(%rbp), %rdi
leaq 0x33ea(%rip), %rsi      # 0x5135
callq 0x47c5
cmpl $0x0, %eax
je 0x1d7f
movq -0x20(%rbp), %rdi
leaq 0x33d9(%rip), %rsi      # 0x5139
callq 0x47c5
cmpl $0x0, %eax
je 0x1d7f
movq -0x20(%rbp), %rdi
leaq 0x33c8(%rip), %rsi      # 0x513d
callq 0x47c5
cmpl $0x0, %eax
jne 0x1d8e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2220
jmp 0x1dfe
movq -0x20(%rbp), %rdi
leaq 0x339b(%rip), %rsi      # 0x5134
callq 0x47c5
cmpl $0x0, %eax
je 0x1dcd
movq -0x20(%rbp), %rdi
leaq 0x338a(%rip), %rsi      # 0x5138
callq 0x47c5
cmpl $0x0, %eax
je 0x1dcd
movq -0x20(%rbp), %rdi
leaq 0x3379(%rip), %rsi      # 0x513c
callq 0x47c5
cmpl $0x0, %eax
jne 0x1ddc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22f0
jmp 0x1dfc
movl $0xffffffd6, %edi       # imm = 0xFFFFFFD6
leaq -0x20(%rbp), %rsi
callq 0x2580
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e17
jmp 0x1dfe
jmp 0x1e00
jmp 0x1e02
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x1c9c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x32e7(%rip), %rsi      # 0x5125
callq 0x47c5
cmpl $0x0, %eax
jne 0x1e53
movq -0x8(%rbp), %rdi
callq 0x1520
jmp 0x1e9b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x32c7(%rip), %rsi      # 0x5128
callq 0x47c5
cmpl $0x0, %eax
jne 0x1e76
movq -0x8(%rbp), %rdi
callq 0x15e0
jmp 0x1e99
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x32a7(%rip), %rsi      # 0x512b
callq 0x47c5
cmpl $0x0, %eax
jne 0x1e97
movq -0x8(%rbp), %rdi
callq 0x16b0
jmp 0x1e99
jmp 0x1e9b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3260(%rip), %rsi      # 0x512e
callq 0x47c5
cmpl $0x0, %eax
jne 0x1ee3
movq -0x8(%rbp), %rdi
callq 0x16e0
jmp 0x1f06
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3240(%rip), %rsi      # 0x5131
callq 0x47c5
cmpl $0x0, %eax
jne 0x1f04
movq -0x8(%rbp), %rdi
callq 0x1740
jmp 0x1f06
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3207(%rip), %rsi      # 0x5135
callq 0x47c5
cmpl $0x0, %eax
jne 0x1f41
movq -0x8(%rbp), %rdi
callq 0x17a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x31ea(%rip), %rsi      # 0x5139
callq 0x47c5
cmpl $0x0, %eax
jne 0x1f62
movq -0x8(%rbp), %rdi
callq 0x1810
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x31cd(%rip), %rsi      # 0x513d
callq 0x47c5
cmpl $0x0, %eax
jne 0x1f83
movq -0x8(%rbp), %rdi
callq 0x1880
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3186(%rip), %rsi      # 0x5134
callq 0x47c5
cmpl $0x0, %eax
jne 0x1fc1
movq -0x8(%rbp), %rdi
callq 0x1990
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3169(%rip), %rsi      # 0x5138
callq 0x47c5
cmpl $0x0, %eax
jne 0x1fe2
movq -0x8(%rbp), %rdi
callq 0x19f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x314c(%rip), %rsi      # 0x513c
callq 0x47c5
cmpl $0x0, %eax
jne 0x2003
movq -0x8(%rbp), %rdi
callq 0x1a50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)