LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/nsc.c
// Function: error
void error(const char *fmt, ...) {
  va_list args;
  fprintf(stderr,
    "\n---> ERROR when executing line %i in file %s !\n",
    __line__,__file__);
  va_start(args,fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n---> Execution stopped !\n\n");
  }

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x1d4ff
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq 0x12ad1(%rip), %rax     # 0x2fff8
movq %rax, (%rsp)
movq (%rax), %rdi
movl 0x14964(%rip), %edx     # 0x31e98
movq 0x14965(%rip), %rcx     # 0x31ea0
leaq 0xf186(%rip), %rsi      # 0x2c6c8
xorl %eax, %eax
movb %al, 0xf(%rsp)
callq 0x2140
movq (%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x8, 0xc0(%rsp)
movq (%rax), %rdi
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x21a0
movq (%rsp), %rcx
movb 0xf(%rsp), %al
movq (%rcx), %rdi
leaq 0xf14b(%rip), %rsi      # 0x2c6f9
callq 0x2140
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/nsc.c
// Function: warning
void warning(const char *fmt, ...) {
  va_list args;
  fprintf(stderr,
    "\n---> WARNING : line %i in file %s\n",
    __line__,__file__);
  va_start(args,fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, " ...!\n\n");
  fflush(stderr);
  fflush(stdout);
  }

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x1d5ff
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq 0x129d1(%rip), %rax     # 0x2fff8
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movl 0x14863(%rip), %edx     # 0x31e98
movq 0x14864(%rip), %rcx     # 0x31ea0
leaq 0xf0d2(%rip), %rsi      # 0x2c715
xorl %eax, %eax
movb %al, 0x7(%rsp)
callq 0x2140
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x8, 0xc0(%rsp)
movq (%rax), %rdi
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x21a0
movq 0x8(%rsp), %rcx
movb 0x7(%rsp), %al
movq (%rcx), %rdi
leaq 0xf088(%rip), %rsi      # 0x2c739
callq 0x2140
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2170
movq 0x1290e(%rip), %rax     # 0x2ffd8
movq (%rax), %rdi
callq 0x2170
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/nsc.c
// Function: safe_asin
double safe_asin(double f) {
  if ( (fabs(f) < 1.00) ) return( asin(f) );
  if ( (fabs(f) - 1.00)  < DP_TOL ) return(HALFPI);
  else ERROR("ASIN : invalid argument %f", f);
  return(0.0);
  }

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movaps 0xe159(%rip), %xmm0     # 0x2b850
pand %xmm0, %xmm1
movsd 0xe0f5(%rip), %xmm0     # 0x2b7f8
ucomisd %xmm1, %xmm0
jbe 0x1d71c
movsd 0x8(%rsp), %xmm0
callq 0x21f0
movsd %xmm0, 0x10(%rsp)
jmp 0x1d78c
movsd 0x8(%rsp), %xmm1
movaps 0xe127(%rip), %xmm0     # 0x2b850
pand %xmm0, %xmm1
movsd 0xe0c3(%rip), %xmm0     # 0x2b7f8
subsd %xmm0, %xmm1
movsd 0xef07(%rip), %xmm0     # 0x2c648
ucomisd %xmm1, %xmm0
jbe 0x1d757
movsd 0xef01(%rip), %xmm0     # 0x2c650
movsd %xmm0, 0x10(%rsp)
jmp 0x1d78c
leaq 0xefe3(%rip), %rax      # 0x2c741
movq %rax, 0x1473b(%rip)     # 0x31ea0
movl $0x61, 0x14729(%rip)    # 0x31e98
movsd 0x8(%rsp), %xmm0
leaq 0xefcb(%rip), %rdi      # 0x2c747
movb $0x1, %al
callq 0x1d4c0
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/nsc.c
// Function: mycalloc
void * mycalloc(const char * filename, const int linenr,
                size_t nelem, size_t elsize) {
  int * ip;
  ip = (int *) calloc(nelem, elsize);
  if(ip) return(ip);
  else ERROR("CALLOC : failed in file %s at line %d", filename, linenr);
  return(void *)ip;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1d7df
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d818
leaq 0xef5b(%rip), %rax      # 0x2c741
movq %rax, 0x146b3(%rip)     # 0x31ea0
movl $0x6b, 0x146a1(%rip)    # 0x31e98
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
leaq 0xef5b(%rip), %rdi      # 0x2c762
movb $0x0, %al
callq 0x1d4c0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/nsc.c
// Function: myrealloc
void * myrealloc(const char * filename, const int linenr,
                 void * ptr, size_t size) {
  int * ip;
  ip = (int *) realloc(ptr, size);
  if(ip) return(ip);
  else ERROR("REALLOC : failed in file %s at line %d", filename, linenr);
  return(void*)ip;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2180
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1d86f
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d8a8
leaq 0xeecb(%rip), %rax      # 0x2c741
movq %rax, 0x14623(%rip)     # 0x31ea0
movl $0x75, 0x14611(%rip)    # 0x31e98
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
leaq 0xeef1(%rip), %rdi      # 0x2c788
movb $0x0, %al
callq 0x1d4c0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/nsc.c
// Function: unsp_type
int unsp_type(int densit) {
  int i1, i2;
  i1 = 1;
  while (10*i1*i1+2 < densit) i1++;
  i2 = 1;
  while (30*i2*i2+2 < densit) i2++;
  if (10*i1*i1-2 < 30*i2*i2-2) return UNSP_ICO_ARC;
  else return UNSP_ICO_DOD;
  }

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
imull $0xa, -0xc(%rsp), %eax
imull -0xc(%rsp), %eax
addl $0x2, %eax
cmpl -0x8(%rsp), %eax
jge 0x20c1c
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x20bfc
movl $0x1, -0x10(%rsp)
imull $0x1e, -0x10(%rsp), %eax
imull -0x10(%rsp), %eax
addl $0x2, %eax
cmpl -0x8(%rsp), %eax
jge 0x20c44
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x20c24
imull $0xa, -0xc(%rsp), %eax
imull -0xc(%rsp), %eax
subl $0x2, %eax
imull $0x1e, -0x10(%rsp), %ecx
imull -0x10(%rsp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x20c6c
movl $0xa, -0x4(%rsp)
jmp 0x20c74
movl $0x9, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/ssbond.c
// Function: ExistSSBond
BOOLEAN ExistSSBond(CHAIN **Chain,int NChain, int Cn1,int Cn2,char *Res1,char *Res2)
{

  register int i;
  SSBOND *ptr;

  for( i=0; i<Chain[0]->NBond; i++ ) {
    ptr = Chain[0]->SSbond[i];
    if( ( !strcmp(Res1,ptr->PDB_ResNumb1) && 
	  !strcmp(Res2,ptr->PDB_ResNumb2) &&
	  FindChain(Chain,NChain,ptr->ChainId1) == Cn1 &&
	  FindChain(Chain,NChain,ptr->ChainId2) == Cn2 ) ||
        ( !strcmp(Res2,ptr->PDB_ResNumb1) && 
          !strcmp(Res1,ptr->PDB_ResNumb2) &&
	  FindChain(Chain,NChain,ptr->ChainId1) == Cn2 &&
	  FindChain(Chain,NChain,ptr->ChainId2) == Cn1 ) )
      return(SUCCESS);
  }

  return(FAILURE);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x23cc1
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x23c3f
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x6, %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x23c3f
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x8(%rsp), %rax
movsbl 0xe(%rax), %edx
callq 0x62d0
cmpl 0x30(%rsp), %eax
jne 0x23c3f
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x8(%rsp), %rax
movsbl 0xf(%rax), %edx
callq 0x62d0
cmpl 0x2c(%rsp), %eax
je 0x23ca5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x23caf
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x6, %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x23caf
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x8(%rsp), %rax
movsbl 0xe(%rax), %edx
callq 0x62d0
cmpl 0x2c(%rsp), %eax
jne 0x23caf
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x8(%rsp), %rax
movsbl 0xf(%rax), %edx
callq 0x62d0
cmpl 0x30(%rsp), %eax
jne 0x23caf
movl $0x1, 0x44(%rsp)
jmp 0x23cc9
jmp 0x23cb1
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x23ba7
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/chk_res.c
// Function: CheckRes
int CheckRes(char *Res)
{
  register int ResTypeCnt;
  int ResTypeNumber = 45;
  static char *Rsd[MAX_ResType] = {
    "ACE", "ALA", "ARG", "ASN", "ASP", "ASX", "CYS", "GLN", "GLU", "GLX", "GLY", "HIS", "ILE", 
    "LEU", "LYS", "MET", "PRO", "PHE", "SER", "THR", "TRP", "TYR", "VAL", "FOR", "UNK", "HOH",
    /* Residues found empirically in the protein files */
/*  1gp1   1gp1   1hne   1tmn   2mcg   5hvp   6cha   1bbo   1ctg   act1   act1   aom1   rom7 */
    "SEC", "ALM", "MSU", "CLT", "PCA", "STA", "EXC", "ABU", "HYP", "HMS", "ASS", "OCT", "CYH",
/*  sod0  7adh   2psg   tim1   tim2   2pia */
    "MN", "INI", "PO3", "SUL", "WAT", "FMN"
    };

  for( ResTypeCnt=0; ResTypeCnt<ResTypeNumber; ResTypeCnt++ )
      if( !strcmp(Res,Rsd[ResTypeCnt]) )
	 return(SUCCESS);

  return(FAILURE);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x2d, (%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x23d39
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0xcf0e(%rip), %rax      # 0x30c20
movq (%rax,%rcx,8), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x23d2a
movl $0x1, 0x14(%rsp)
jmp 0x23d41
jmp 0x23d2c
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x23cf8
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/chk_atom.c
// Function: CheckAtom
int CheckAtom(char *At)
{
  int AtomTypeCnt, AtomTypeNumber = 95;
  static char *Atom[MAX_AtomType] = {
    "AD1", "AD2", "AE1", "AE2", "C", "CA", "CB", "CD", "CD1", "CD2", "CE", "CE1", "CE2", 
    "CE3", "CG", "CG1", "CG2", "CH2", "CH3", "CZ", "CZ2", "CZ3", "HG", "HG1", "HH", "HH2", 
    "HZ", "HZ2", "HZ3", "N", "ND1", "ND2", "NE", "NE1", "NE2", "NH1", "NH2", "NZ", "O", 
    "OD1", "OD2", "OE", "OE1", "OE2", "OG", "OG1", "OH", "OXT", "SD", "SG", "H", "HA", "HB", 
    "HD1", "HD2", "HE", "HE1", "HE2", "HE3", "1H", "1HA", "1HB", "1HD", "1HD1", "1HD2", 
    "1HE", "1HE2", "1HG", "1HG1", "1HG2", "1HH1", "1HH2", "1HZ", "2H", "2HA", "2HB", "2HD", 
    "2HD1", "2HD2", "2HE", "2HE2", "2HG", "2HG1", "2HG2", "2HH1", "2HH2", "2HZ", "3H", "3HB", 
    "3HD1", "3HD2", "3HE", "3HG1", "3HG2", "3HZ"
    };

  for( AtomTypeCnt=0; AtomTypeCnt<AtomTypeNumber; AtomTypeCnt++ )
    if( !strcmp(At,Atom[AtomTypeCnt]) ) 
      return(SUCCESS);

  return(FAILURE);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x5f, (%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x23da9
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0xd02e(%rip), %rax      # 0x30db0
movq (%rax,%rcx,8), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x23d9a
movl $0x1, 0x14(%rsp)
jmp 0x23db1
jmp 0x23d9c
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x23d68
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/dssp.c
// Function: CompPdbDssp
int CompPdbDssp(CHAIN *Chain, DSSP *Dssp)
{

  int Res, CA;

  /* If the first or the last PDB residue does not have Ca, insert one residue in
     coil conformation in the beginning or in the end of the DSSP chain */
  if( !FindAtom(Chain,0,"CA",&CA) ) 
    InsertFirst(Dssp,Chain);

  if( Chain->NRes-1 > 0 && !FindAtom(Chain,Chain->NRes-1,"CA",&CA) ) 
    InsertLast(Dssp,Chain);

  /* Check correspondence of residue types */
  for( Res=0; Res<Chain->NRes; Res++ )
    if( strcmp(Chain->Rsd[Res]->ResType,Dssp->ResType[Res]) )
      return(FAILURE);

  /* If DSSP chain is still longer than PDB chain, shrink it */
  if( Chain->NRes != Dssp->NRes ) 
    Dssp->NRes = Chain->NRes;

  return(SUCCESS);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
leaq 0x7534(%rip), %rdx      # 0x2cc40
leaq 0x8(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
jne 0x2572a
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x25810
movq 0x18(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x2576d
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
subl $0x1, %esi
leaq 0x74f1(%rip), %rdx      # 0x2cc40
leaq 0x8(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
jne 0x2576d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x25950
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x257d0
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0xa, %rdi
movq 0x10(%rsp), %rax
movq 0x408(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2130
cmpl $0x0, %eax
je 0x257c1
movl $0x0, 0x24(%rsp)
jmp 0x257fe
jmp 0x257c3
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x25775
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x404(%rcx), %eax
je 0x257f6
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x404(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/dssp.c
// Function: InsertFirst
void InsertFirst(DSSP *Dssp, CHAIN *Chain)
{
  int Res;

  for( Res=Dssp->NRes; Res>=1; Res-- ) {
    strcpy(Dssp->ResType[Res],Dssp->ResType[Res-1]);
    strcpy(Dssp->PDB_ResNumb[Res],Dssp->PDB_ResNumb[Res-1]);
    Dssp->SecondStr[Res] = Dssp->SecondStr[Res-1];
  }

  strcpy(Dssp->ResType[0],Chain->Rsd[0]->ResType);
  strcpy(Dssp->PDB_ResNumb[0],Chain->Rsd[0]->PDB_ResNumb);
  Dssp->SecondStr[0] = 'C';
  
  Dssp->NRes++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x404(%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jl 0x258dd
movq 0x10(%rsp), %rax
movq 0x408(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x408(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movq 0x418(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x418(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movq 0x410(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2582d
movq 0x10(%rsp), %rax
movq 0x408(%rax), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rsi
addq $0xa, %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movq 0x418(%rax), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rsi
addq $0x4, %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movq 0x410(%rax), %rax
movb $0x43, (%rax)
movq 0x10(%rsp), %rax
movl 0x404(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x404(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/dssp.c
// Function: InsertLast
void InsertLast(DSSP *Dssp, CHAIN *Chain)
{

  strcpy(Dssp->ResType[Dssp->NRes],Chain->Rsd[Dssp->NRes]->ResType);
  strcpy(Dssp->PDB_ResNumb[Dssp->NRes],Chain->Rsd[Dssp->NRes]->PDB_ResNumb);
  Dssp->SecondStr[Dssp->NRes] = 'C';
  
  Dssp->NRes++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x404(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x404(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
addq $0xa, %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movq 0x418(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x404(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x404(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x4, %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movq 0x410(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x404(%rcx), %rcx
movb $0x43, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x404(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x404(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/chkchain.c
// Function: NotValid
int NotValid(CHAIN *Chain, char *Message)
{
  
  fprintf(stderr,"IGNORED %s %c ",Chain->File,SpaceToDash(Chain->Id));
  fprintf(stderr,"(%s)\n",Message);
  Chain->Valid = NO;
  return(FAILURE);
  
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x8fd3(%rip), %rax      # 0x2fff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movsbl 0x40(%rax), %edi
callq 0x6550
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movsbl %al, %ecx
leaq 0x5ce4(%rip), %rsi      # 0x2cd41
movb $0x0, %al
callq 0x2140
movq 0x8f8d(%rip), %rax      # 0x2fff8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x5cd6(%rip), %rsi      # 0x2cd50
movb $0x0, %al
callq 0x2140
movq 0x20(%rsp), %rax
movl $0x0, 0x58(%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/asngener.c
// Function: CorrectAsn
void CorrectAsn(char *Asn, int Length, char SecStrType, char EditChar, int MaxLength)
{

  int NStr = 0, Res, Flag = 0, Bound[MAX_ASSIGN][2], i;

  for( Res=0; Res<Length; Res++ ) {
    if( Asn[Res] == SecStrType && Flag == 0 ) {
      Flag = 1; 
      Bound[NStr][0] = Res;
    }
    else
    if( Asn[Res] != SecStrType && Flag == 1 ) {
      Flag = 0; 
      Bound[NStr++][1] = Res-1;
    }
  }

  for( i=0; i<NStr; i++ )
    if( Bound[i][1]-Bound[i][0]+1 <= MaxLength )
      for( Res=Bound[i][0]; Res<=Bound[i][1]; Res++ ) 
	Asn[Res] = EditChar;
}

// Assembly:
subq $0xf58, %rsp            # imm = 0xF58
movb %cl, %al
movb %dl, %cl
movq %rdi, 0xf50(%rsp)
movl %esi, 0xf4c(%rsp)
movb %cl, 0xf4b(%rsp)
movb %al, 0xf4a(%rsp)
movl %r8d, 0xf44(%rsp)
movl $0x0, 0xf40(%rsp)
movl $0x0, 0xf38(%rsp)
movl $0x0, 0xf3c(%rsp)
movl 0xf3c(%rsp), %eax
cmpl 0xf4c(%rsp), %eax
jge 0x29211
movq 0xf50(%rsp), %rax
movslq 0xf3c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0xf4b(%rsp), %ecx
cmpl %ecx, %eax
jne 0x2919f
cmpl $0x0, 0xf38(%rsp)
jne 0x2919f
movl $0x1, 0xf38(%rsp)
movl 0xf3c(%rsp), %ecx
movslq 0xf40(%rsp), %rax
movl %ecx, -0x70(%rsp,%rax,8)
jmp 0x291f9
movq 0xf50(%rsp), %rax
movslq 0xf3c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0xf4b(%rsp), %ecx
cmpl %ecx, %eax
je 0x291f7
cmpl $0x1, 0xf38(%rsp)
jne 0x291f7
movl $0x0, 0xf38(%rsp)
movl 0xf3c(%rsp), %ecx
subl $0x1, %ecx
movl 0xf40(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xf40(%rsp)
cltq
movl %ecx, -0x6c(%rsp,%rax,8)
jmp 0x291f9
jmp 0x291fb
movl 0xf3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf3c(%rsp)
jmp 0x29141
movl $0x0, -0x74(%rsp)
movl -0x74(%rsp), %eax
cmpl 0xf40(%rsp), %eax
jge 0x292ab
movslq -0x74(%rsp), %rax
movl -0x6c(%rsp,%rax,8), %eax
movslq -0x74(%rsp), %rcx
subl -0x70(%rsp,%rcx,8), %eax
addl $0x1, %eax
cmpl 0xf44(%rsp), %eax
jg 0x29299
movslq -0x74(%rsp), %rax
movl -0x70(%rsp,%rax,8), %eax
movl %eax, 0xf3c(%rsp)
movl 0xf3c(%rsp), %eax
movslq -0x74(%rsp), %rcx
cmpl -0x6c(%rsp,%rcx,8), %eax
jg 0x29297
movb 0xf4a(%rsp), %dl
movq 0xf50(%rsp), %rax
movslq 0xf3c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xf3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf3c(%rsp)
jmp 0x29258
jmp 0x29299
jmp 0x2929b
movl -0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rsp)
jmp 0x29219
addq $0xf58, %rsp            # imm = 0xF58
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/asngener.c
// Function: PercentCorrect
float PercentCorrect(char *TestAsn, char *KnownAsn, int Length)
{
  int Res, Count=0;;

  for( Res=0; Res<Length; Res++ )
    if( KnownAsn[Res] == TestAsn[Res] )
      Count++;

  return( ((float)Count/(float)Length) );
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x29752
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rsp), %rcx
movslq -0x18(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x29743
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x29745
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x2970e
cvtsi2ssl -0x1c(%rsp), %xmm0
cvtsi2ssl -0x14(%rsp), %xmm1
divss %xmm1, %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/asngener.c
// Function: AssessCorr
int AssessCorr(QUALITY *Qual)
{

  float TP, TN, FP, FN;

  if( (Qual->TP == 0 && Qual->FN == 0) || (Qual->TP == 0 && Qual->FP == 0) ) return(FAILURE);
  else {
    TP = (float)Qual->TP; 
    TN = (float)Qual->TN; 
    FP = (float)Qual->FP; 
    FN =(float)Qual->FN;

    Qual->Corr = (TP*TN - FN*FP)/sqrt((TN+FN)*(TN+FP)*(TP+FN)*(TP+FP));

    return(SUCCESS);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x2978e
movq 0x18(%rsp), %rax
cmpl $0x0, 0xc(%rax)
je 0x297a3
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x297b0
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x297b0
movl $0x0, 0x24(%rsp)
jmp 0x2988c
movq 0x18(%rsp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x18(%rsp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x18(%rsp), %rax
cvtsi2ssl 0xc(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm2
movss 0x8(%rsp), %xmm1
mulss 0xc(%rsp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movss 0x10(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
addss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x14(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x14(%rsp), %xmm1
addss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2220
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, 0x10(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/asngener.c
// Function: AssessPerc
int AssessPerc(QUALITY *Qual)
{

  float TP, TN, FP, FN;

  TP = (float)Qual->TP; 
  TN = (float)Qual->TN; 
  FP = (float)Qual->FP; 
  FN =(float)Qual->FN;

  Qual->Perc = (TP+TN)/(TP+TN+FP+FN);

  return(SUCCESS);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, -0xc(%rsp)
movq -0x8(%rsp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movss %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movss %xmm0, -0x14(%rsp)
movq -0x8(%rsp), %rax
cvtsi2ssl 0xc(%rax), %xmm0
movss %xmm0, -0x18(%rsp)
movss -0xc(%rsp), %xmm0
addss -0x10(%rsp), %xmm0
movss -0xc(%rsp), %xmm1
addss -0x10(%rsp), %xmm1
addss -0x14(%rsp), %xmm1
addss -0x18(%rsp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, 0x14(%rax)
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/asngener.c
// Function: ExcludeObvious
void ExcludeObvious(char *Asn1, char *Asn2, char *KnownAsn, int Length)
{
  register int i;

  for( i=0; i<Length; i++ )
    if( Asn1[i] == Asn2[i] ) {
      KnownAsn[i] = 'X';
      Asn1[i] = 'X';
      Asn2[i] = 'X';
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x2999e
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movslq -0x20(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2998f
movq -0x18(%rsp), %rax
movslq -0x20(%rsp), %rcx
movb $0x58, (%rax,%rcx)
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
movb $0x58, (%rax,%rcx)
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movb $0x58, (%rax,%rcx)
jmp 0x29991
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x2993b
retq
nop
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/p_endmdl.c
// Function: Process_ENDMDL
int Process_ENDMDL(BUFFER Buffer, CHAIN **Chain, int *ChainNumber)
{

  int CC;

  for( CC=0; CC < *ChainNumber; CC++ )
    Chain[CC]->Ter = 1;
  
  return(SUCCESS);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x299e6
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0xc(%rax)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x299b7
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/stred.c
// Function: Replace
int Replace(char *String, char From, char To)
{

  int Replaced=0;

  if( From == '\0' )
    return(Replaced);

  for( ; *String != '\0'; String++ )
    if( *String == From ) {
      *String = To;
    Replaced++;
    }

  return(Replaced);
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movl $0x0, -0x18(%rsp)
movsbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x29a1e
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x29a6e
jmp 0x29a20
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x29a66
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x29a54
movb -0x12(%rsp), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x29a56
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x29a20
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/stred.c
// Function: Delete
int Delete(char *String, char From)
{
  
  int Deleted = 0;
  char *c;
  
  if( From == '\0' )
    return(Deleted);
  
  for( ; *String != '\0'; String++ )
    if( *String == From ) {
      c = String;
      for( ;; c++ ) {
	*c = *(c+1);
	if( *c == '\0' ) 
	  break;
      }
      Deleted++;
      String--;
    }
  return(Deleted);
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movl $0x0, -0x18(%rsp)
movsbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x29aab
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x29b3b
jmp 0x29aad
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x29b33
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x29b1e
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x29af3
jmp 0x29b05
jmp 0x29af5
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x29ad5
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x29b20
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x29aad
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_03/syscalls.c
// Function: main
int main(void)
{
  FILE *file_in_p;
  FILE *file_out_p;

  if ((file_in_p = file_open("syscalls.c", "r")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  if ((file_out_p = file_open("out.txt", "w")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  char c;
  while ((c = getc(file_in_p)) != EOF)
  {
    putc(c, file_out_p);
  }
  file_close(file_in_p);
  file_close(file_out_p);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x89e(%rip), %rdi       # 0x2004
leaq 0x8a2(%rip), %rsi       # 0x200f
callq 0x14d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x179e
movl $0x1, %edi
leaq 0x889(%rip), %rsi       # 0x2011
movl $0x21, %edx
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x187c
leaq 0x88d(%rip), %rdi       # 0x2032
leaq 0x88e(%rip), %rsi       # 0x203a
callq 0x14d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17dd
movl $0x1, %edi
leaq 0x84a(%rip), %rsi       # 0x2011
movl $0x21, %edx
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x187c
jmp 0x17df
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jl 0x180a
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x1816
movq -0x10(%rbp), %rdi
callq 0x11b0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1863
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jl 0x1851
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb %al, (%rcx)
movsbl %al, %eax
jmp 0x185e
movsbl -0x19(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1300
jmp 0x17df
movq -0x10(%rbp), %rdi
callq 0x16c0
movq -0x18(%rbp), %rdi
callq 0x16c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/main.c
// Function: master_loop
int		master_loop(t_control *control)
{
	t_list	*tokens_list;
	t_btree	*ast;

	while (!control->quit)
	{
		if (!termios_enable_raw_mode(control, &control->termios_default))
			break ;
		tokens_list = input_root(control);
		if (!termios_reset_cooked_mode(control, &control->termios_default))
			break ;
		if (control->quit || control->ctrl_c || control->lexer_end.unexpected)
			continue;
		ast = parser_root(tokens_list, control);
		if (control->quit)
			break ;
		exe_root(ast, control);
		btree_clear(&ast, del_token);
	}
	return (control->exit_status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2358
jmp 0x240e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x3c, %rsi
callq 0x5310
cmpl $0x0, %eax
jne 0x2373
jmp 0x240e
movq -0x8(%rbp), %rdi
callq 0x4d10
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x3c, %rsi
callq 0x5460
cmpl $0x0, %eax
jne 0x2398
jmp 0x240e
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x23c4
movq -0x8(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x23c4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x23c9
jmp 0x233c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x8f40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x23ec
jmp 0x240e
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x94e0
leaq -0x18(%rbp), %rdi
leaq 0x53c(%rip), %rsi       # 0x2940
callq 0x10e70
jmp 0x233c
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/main.c
// Function: main
int		main(void)
{
	int				exit_status;
	t_control		control;

	ft_signalhandler_enable();
	if (!control_init_struct(&control) ||
		!(termios_enable_raw_mode(&control, &control.termios_default)))
	{
		ft_perror(NULL, NULL, errno ? strerror(errno) : "Couldn't initialize");
		control_free_struct(&control);
		return (1);
	}
	exit_status = master_loop(&control);
	control_free_struct(&control);
	terminfo_reset_terminal();
	termios_reset_cooked_mode(&control, &control.termios_default);
	return (exit_status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
callq 0xd6b0
leaq -0x88(%rbp), %rdi
callq 0x8690
cmpl $0x0, %eax
je 0x2464
leaq -0x88(%rbp), %rsi
addq $0x3c, %rsi
leaq -0x88(%rbp), %rdi
callq 0x5310
cmpl $0x0, %eax
jne 0x24bb
callq 0x2040
cmpl $0x0, (%rax)
je 0x2483
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, -0x90(%rbp)
jmp 0x2493
leaq 0xeb7a(%rip), %rax      # 0x11004
movq %rax, -0x90(%rbp)
jmp 0x2493
movq -0x90(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x2620
leaq -0x88(%rbp), %rdi
callq 0x8880
movl $0x1, -0x4(%rbp)
jmp 0x24f8
leaq -0x88(%rbp), %rdi
callq 0x2330
movl %eax, -0x8(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8880
callq 0x57c0
leaq -0x88(%rbp), %rsi
addq $0x3c, %rsi
leaq -0x88(%rbp), %rdi
callq 0x5460
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_fork
void	ft_fork(pid_t *pid)
{
	*pid = fork();
	if (*pid == -1)
		ft_exit("fork", NULL, strerror(errno), EXIT_FAILURE);
	errno = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2220
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x25d6
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, %rdx
leaq 0xea55(%rip), %rdi      # 0x1101d
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %ecx
callq 0x2560
callq 0x2040
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_perror
int		ft_perror(char *cmd, char *param, char *str)
{
	const int fd = STDERR_FILENO;

	ft_putstr_fd("\033[0;91m", fd);
	ft_putstr_fd("minishell: ", fd);
	if (cmd)
	{
		ft_putstr_fd(cmd, fd);
		ft_putstr_fd(": ", fd);
	}
	if (param)
	{
		ft_putstr_fd("`", fd);
		ft_putstr_fd(param, fd);
		ft_putstr_fd("': ", fd);
	}
	if (errno && !str)
		str = strerror(errno);
	if (str)
	{
		ft_putstr_fd("Error: ", fd);
		ft_putendl_fd(str, fd);
	}
	ft_putstr_fd("\033[0m", fd);
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, -0x1c(%rbp)
leaq 0xe9e0(%rip), %rdi      # 0x11022
movl $0x2, %esi
callq 0xf020
leaq 0xe9d7(%rip), %rdi      # 0x1102a
movl $0x2, %esi
callq 0xf020
cmpq $0x0, -0x8(%rbp)
je 0x2683
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf020
leaq 0xed15(%rip), %rdi      # 0x1138e
movl $0x2, %esi
callq 0xf020
cmpq $0x0, -0x10(%rbp)
je 0x26ba
leaq 0xeb90(%rip), %rdi      # 0x11221
movl $0x2, %esi
callq 0xf020
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xf020
leaq 0xe986(%rip), %rdi      # 0x11036
movl $0x2, %esi
callq 0xf020
callq 0x2040
cmpl $0x0, (%rax)
je 0x26db
cmpq $0x0, -0x18(%rbp)
jne 0x26db
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2701
leaq 0xe951(%rip), %rdi      # 0x1103a
movl $0x2, %esi
callq 0xf020
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0xef40
leaq 0xf509(%rip), %rdi      # 0x11c11
movl $0x2, %esi
callq 0xf020
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_ambiguous_redirect
void	ft_ambiguous_redirect(char *str, int fd)
{
	ft_putstr_fd("\033[0;91m", fd);
	ft_putstr_fd("minishell: ", fd);
	ft_putstr_fd(str, fd);
	ft_putstr_fd(": ambiguous redirect\n", fd);
	ft_putstr_fd("\033[0m", fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0xe8e9(%rip), %rdi      # 0x11022
callq 0xf020
movl -0xc(%rbp), %esi
leaq 0xe8e2(%rip), %rdi      # 0x1102a
callq 0xf020
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xf020
movl -0xc(%rbp), %esi
leaq 0xe8df(%rip), %rdi      # 0x11042
callq 0xf020
movl -0xc(%rbp), %esi
leaq 0xf49f(%rip), %rdi      # 0x11c11
callq 0xf020
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_root.c
// Function: lexer_root
t_list	*lexer_root(char *input, t_control *control)
{
	t_list	*tokens_head;
	t_list	*tokens_elem;
	t_token	*new_token;
	int		i;

	i = 0;
	tokens_head = NULL;
	while (input[i])
	{
		tokens_elem = NULL;
		if ((!(new_token = lexer_build_next_token(input, &i, control)) &&
		control->quit) || (new_token && !(tokens_elem = ft_lstnew(new_token))))
		{
			control->quit = 1;
			del_token(new_token);
			ft_lstclear(&tokens_head, del_token);
			return (NULL);
		}
		ft_lstadd_back(&tokens_head, tokens_elem);
		//debug_token_struct(new_token);
	}
	ft_bzero(&control->lexer_end, sizeof(lexer_end));
	if (!lexer_end(tokens_head, control))
		ft_lstclear(&tokens_head, del_token);
	//debug_lexer_flags(control);
	//debug_tokens_list(tokens_head);
	return (tokens_head);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2841
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rsi
callq 0x2890
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x27e4
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x27fe
cmpq $0x0, -0x30(%rbp)
je 0x282f
movq -0x30(%rbp), %rdi
callq 0x10180
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x282f
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rdi
callq 0x2940
leaq -0x20(%rbp), %rdi
leaq 0x120(%rip), %rsi       # 0x2940
callq 0x10090
movq $0x0, -0x8(%rbp)
jmp 0x287d
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xfff0
jmp 0x279f
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0xe940
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3680
cmpl $0x0, %eax
jne 0x2875
leaq -0x20(%rbp), %rdi
leaq 0xd0(%rip), %rsi        # 0x2940
callq 0x10090
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_root.c
// Function: lexer_build_next_token
t_token	*lexer_build_next_token(const char *input, int *j, t_control *control)
{
	t_token		*token;

	token = NULL;
	while (input[*j] == ' ')
		(*j)++;
	if (!input[*j])
		return (token);
	if (!(token = lexer_init_token()) ||
		!lexer_find_token(input, j, token))
	{
		control->quit = 1;
		del_token(token);
		return (NULL);
	}
	return (token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x28cd
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x28ac
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x28e8
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2936
callq 0x29b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x290d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29f0
cmpl $0x0, %eax
jne 0x292e
movq -0x20(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2940
movq $0x0, -0x8(%rbp)
jmp 0x2936
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_root.c
// Function: del_token
void	del_token(void *token)
{
	if (!token)
		return ;
	if (token_id(token) == CMD)
		free_t_simple_cmd((t_simple_cmd**)(((t_token *)token)->str));
	else if (token_id(token) == LIST)
		ft_lstclear((t_list **)&(((t_token *)token)->str), del_token);
	else
		ft_free((void **)&(((t_token *)token)->str));
	ft_free(&token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2955
jmp 0x29a5
movq -0x8(%rbp), %rdi
callq 0x9300
cmpl $0x10, %eax
jne 0x2971
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd3d0
jmp 0x299c
movq -0x8(%rbp), %rdi
callq 0x9300
cmpl $0xf, %eax
jne 0x2991
movq -0x8(%rbp), %rdi
leaq -0x4a(%rip), %rsi       # 0x2940
callq 0x10090
jmp 0x299a
movq -0x8(%rbp), %rdi
callq 0x10600
jmp 0x299c
leaq -0x8(%rbp), %rdi
callq 0x10600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_find_token.c
// Function: lexer_find_token
int	lexer_find_token(const char *input, int *j, t_token *token)
{
	if (!input[*j])
		return (1);
	if (input[*j] == '\\')
		return (lexer_just_token(input, j, token));
	else if (ft_strchr("\"\'", input[*j]))
		return (lexer_quoted(input, j, token));
	else if (ft_strchr("&<>()|;", input[*j]))
		return (lexer_operator(input, j, token));
	else if (ft_isdigit(input[*j]))
		return (lexer_token_or_indirection(input, j, token));
	return (lexer_just_token(input, j, token));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x2a21
movl $0x1, -0x4(%rbp)
jmp 0x2b08
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x2a4e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3040
movl %eax, -0x4(%rbp)
jmp 0x2b08
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe5f4(%rip), %rdi      # 0x11058
callq 0xf8d0
cmpq $0x0, %rax
je 0x2a88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2b50
movl %eax, -0x4(%rbp)
jmp 0x2b08
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe5bd(%rip), %rdi      # 0x1105b
callq 0xf8d0
cmpq $0x0, %rax
je 0x2abf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2df0
movl %eax, -0x4(%rbp)
jmp 0x2b08
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %edi
callq 0xe9f0
cmpl $0x0, %eax
je 0x2aee
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3210
movl %eax, -0x4(%rbp)
jmp 0x2b08
jmp 0x2af0
jmp 0x2af2
jmp 0x2af4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3040
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted
int	lexer_quoted(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	token->open_quote = 1;
	if (c == '\'')
	{
		token->id = S_QUOTE;
		return (lexer_quoted_single(input, c, j, token));
	}
	else
	{
		token->id = D_QUOTE;
		return (lexer_quoted_double(input, c, j, token));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10460
cmpl $0x0, %eax
jne 0x2b90
movl $0x0, -0x4(%rbp)
jmp 0x2c00
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movb 0x10(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x10(%rax)
movsbl -0x21(%rbp), %eax
cmpl $0x27, %eax
jne 0x2bdb
movq -0x20(%rbp), %rax
movl $0x8, 0x8(%rax)
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x2c10
movl %eax, -0x4(%rbp)
jmp 0x2c00
movq -0x20(%rbp), %rax
movl $0x9, 0x8(%rax)
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x2cd0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_single
int	lexer_quoted_single(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2cb9
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10460
cmpl $0x0, %eax
jne 0x2c61
movl $0x0, -0x4(%rbp)
jmp 0x2cc0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2ca9
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movb 0x10(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29f0
movl %eax, -0x4(%rbp)
jmp 0x2cc0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2c2a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_double
int	lexer_quoted_double(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (!token->esc_next && input[*j] == '\\' && lexer_jump_esc(j, token))
			continue;
		else if (!token->esc_next && input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2de0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10460
cmpl $0x0, %eax
jne 0x2d28
movl $0x0, -0x4(%rbp)
jmp 0x2de7
movq -0x28(%rbp), %rax
movb 0x10(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2d63
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x2d63
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2b20
cmpl $0x0, %eax
je 0x2d63
jmp 0x2cea
movq -0x28(%rbp), %rax
movb 0x10(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2dbe
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2dbe
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movb 0x10(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29f0
movl %eax, -0x4(%rbp)
jmp 0x2de7
jmp 0x2dc0
movq -0x28(%rbp), %rax
movb 0x10(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x10(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2cea
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq