LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: bilinearTexSampling1
unsigned char bilinearTexSampling1(unsigned char *d, int width, int height,
                                   float u, float v) {
  //from jonolick.com
  int ww = width-1, hh = height-1;
  float fu = (u + 1000.0f) * ww; // NOTE: assumes less than 1000 repeats
  float fv = (v + 1000.0f) * hh;
  int u1 = ((int)fu) % ww;
  int v1 = ((int)fv) % hh;
  int u2 = (u1 + 1) % ww;
  int v2 = (v1 + 1) % hh;
  float fracu = fu - floorf( fu );
  float fracv = fv - floorf( fv );
  float w[4] = {(1 - fracu) * (1 - fracv), fracu * (1 - fracv), (1 - fracu) * fracv, fracu *  fracv};
  unsigned char c[4] = { d[v1*width + u1], d[v1*width + u2], d[v2*width + u1], d[v2*width + u2] };
  return (unsigned char)(c[0]*w[0] + c[1]*w[1] + c[2]*w[2] + c[3]*w[3]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ecx
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %edi
decl %ecx
movss 0xc2d27(%rip), %xmm2    # 0x4d52f0
addss %xmm2, %xmm0
cvtsi2ss %edi, %xmm3
mulss %xmm0, %xmm3
cvtsi2ss %ecx, %xmm0
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
cvttss2si %xmm3, %eax
movss %xmm3, (%rsp)
cltd
cvttss2si %xmm0, %esi
idivl %edi
movl %edx, %r15d
movl %esi, %eax
cltd
idivl %ecx
movl %edx, %r12d
leal 0x1(%r15), %eax
cltd
idivl %edi
movl %edx, %ebp
leal 0x1(%r12), %eax
cltd
idivl %ecx
movl %edx, %r13d
movaps %xmm3, %xmm0
callq 0x401150
movss (%rsp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rsp)
movss 0x4(%rsp), %xmm0
callq 0x401150
movss 0x4(%rsp), %xmm4
subss %xmm0, %xmm4
movss 0xbfe17(%rip), %xmm1    # 0x4d2460
movaps %xmm1, %xmm0
movss (%rsp), %xmm3
subss %xmm3, %xmm0
subss %xmm4, %xmm1
movaps %xmm0, %xmm2
mulss %xmm1, %xmm2
mulss %xmm3, %xmm1
mulss %xmm4, %xmm0
mulss %xmm3, %xmm4
imull %r14d, %r12d
leal (%r12,%r15), %eax
cltq
movzbl (%rbx,%rax), %eax
addl %ebp, %r12d
movslq %r12d, %rcx
movzbl (%rbx,%rcx), %ecx
imull %r14d, %r13d
addl %r13d, %r15d
movslq %r15d, %rdx
movzbl (%rbx,%rdx), %edx
addl %ebp, %r13d
movslq %r13d, %rsi
cvtsi2ss %eax, %xmm3
mulss %xmm2, %xmm3
cvtsi2ss %ecx, %xmm2
mulss %xmm1, %xmm2
cvtsi2ss %edx, %xmm1
movzbl (%rbx,%rsi), %eax
addss %xmm3, %xmm2
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
cvtsi2ss %eax, %xmm0
mulss %xmm4, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: calcBounds
void calcBounds(struct Triangle *triangles,int trianglesNum,
                struct Sphere *spheres,int spheresNum,
                float *minBound,float *maxBound,
                struct BoundingBox *bounds) {
  int i,j;

  //triangle bounds
  for(i=0;i<trianglesNum;i++) {
    triangleBoundingBox(triangles[i].pt0,
                        triangles[i].pt1,
                        triangles[i].pt2,
                        bounds[i].start,
                        bounds[i].end);
  }

  //sphere bounds
  for(i=0;i<spheresNum;i++) {
    sphereBoundingBox(spheres[i].pos,spheres[i].radius,
                      bounds[trianglesNum+i].start,
                      bounds[trianglesNum+i].end);
  }

  //insert primitives here

  //min,max bounds
  if(trianglesNum+spheresNum > 0) {
    for(i=0;i<3;i++) {
      minBound[i]=bounds[0].start[i];
      maxBound[i]=bounds[0].end[i];

      for(j=1;j<trianglesNum+spheresNum;j++) {
        if(bounds[j].start[i] < minBound[i]) {
          minBound[i]=bounds[j].start[i];
        }

        if(bounds[j].end[i] > maxBound[i]) {
          maxBound[i]=bounds[j].end[i];
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
movq %rdi, %r13
movq 0x40(%rsp), %r15
xorl %ebp, %ebp
testl %esi, %esi
movl %esi, (%rsp)
cmovgl %esi, %ebp
addq $0x34, %r13
subq $0x1, %rbp
jb 0x412d3a
leaq -0x18(%r13), %rdi
leaq -0xc(%r13), %rsi
leaq 0xc(%r15), %r8
movq %r13, %rdx
movq %r15, %rcx
callq 0x40819f
addq $0x18, %r15
addq $0x74, %r13
jmp 0x412d13
xorl %r15d, %r15d
movl 0x4(%rsp), %eax
testl %eax, %eax
cmovgl %eax, %r15d
movslq (%rsp), %rax
imulq $0x18, %rax, %r13
movq 0x40(%rsp), %rbp
addq %rbp, %r13
addq $0x1c, %r12
subq $0x1, %r15
jb 0x412d81
movss 0xc(%r12), %xmm0
leaq 0xc(%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x408234
addq $0x18, %r13
addq $0x2c, %r12
jmp 0x412d5b
movl 0x4(%rsp), %eax
addl (%rsp), %eax
jle 0x412dfa
movl %eax, %eax
imulq $0x18, %rax, %rax
xorl %ecx, %ecx
pushq $0x18
popq %rdx
movq %rbp, %rsi
cmpq $0x3, %rcx
je 0x412dfa
movss (%rbp,%rcx,4), %xmm0
movss %xmm0, (%r14,%rcx,4)
movss 0xc(%rbp,%rcx,4), %xmm0
movss %xmm0, (%rbx,%rcx,4)
movq %rdx, %rdi
cmpq %rdi, %rax
je 0x412df1
movss (%rsi,%rdi), %xmm1
movss (%r14,%rcx,4), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x412dd8
movss %xmm1, (%r14,%rcx,4)
movss (%rbx,%rcx,4), %xmm0
movss 0xc(%rsi,%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x412deb
movss %xmm1, (%rbx,%rcx,4)
movaps %xmm1, %xmm0
addq $0x18, %rdi
jmp 0x412db8
incq %rcx
addq $0x4, %rsi
jmp 0x412d98
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: calc_pointLight
void calc_pointLight(const struct PointLight *pointLight,
                     const float *toLightDir,
                     float lightDist,
                     const float *rayDir,
                     float shininess,float intensity,
                     const float *nor,
                     float *outCol,float *outSpec) {

  float fromLightDir[3],atten,eyeDir[3],reflectVec[3],NdotL,spec,diffuse;

  //
  vec3_mulScalar(fromLightDir,toLightDir,-1.0f);

  atten = 1.0f/(pointLight->constAtten+
                pointLight->linAtten*lightDist+
                pointLight->quadAtten*lightDist*lightDist);

  vec3_mulScalar(eyeDir,rayDir,-1.0f);

  reflect(reflectVec,fromLightDir,nor);

  NdotL = maxOf(0.0f, vec3_dot(nor, toLightDir));

  spec=0.0f;

  if(NdotL > 0.0f) {
    float EdotR;

    EdotR=maxOf(0.0f, vec3_dot(eyeDir, reflectVec));
    spec+=powf(EdotR,shininess*128.0f) *intensity;
    spec*=atten;
  }

  diffuse=NdotL*atten;

  outCol[0]=pointLight->col[0]*diffuse;
  outCol[1]=pointLight->col[1]*diffuse;
  outCol[2]=pointLight->col[2]*diffuse;

  *outSpec=spec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r12
movss %xmm2, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movq %rdx, %rbx
movss %xmm0, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r15
leaq 0x3c(%rsp), %rbp
movss 0xc0df6(%rip), %xmm0    # 0x4d3c40
movq %rbp, %rdi
callq 0x406fe5
movss 0x1c(%r15), %xmm0
movss 0x8(%rsp), %xmm2
mulss %xmm2, %xmm0
addss 0x18(%r15), %xmm0
movss 0x20(%r15), %xmm1
mulss %xmm2, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0xbf5de(%rip), %xmm0    # 0x4d2460
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movss 0xc0da4(%rip), %xmm0    # 0x4d3c40
callq 0x406fe5
leaq 0x24(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x407a15
movq %r12, %rdi
movq %r13, %rsi
callq 0x406f00
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
callq 0x407a79
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x412f1f
leaq 0x30(%rsp), %rdi
leaq 0x24(%rsp), %rsi
movss %xmm0, 0xc(%rsp)
callq 0x406f00
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
callq 0x407a79
movss 0x10(%rsp), %xmm1
mulss 0xc23f7(%rip), %xmm1    # 0x4d52f4
callq 0x401040
movaps %xmm0, %xmm2
movss 0xc(%rsp), %xmm0
mulss 0x14(%rsp), %xmm2
addss 0xbf573(%rip), %xmm2    # 0x4d248c
mulss 0x8(%rsp), %xmm2
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
movss (%r15), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r14)
movss 0x4(%r15), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%r14)
mulss 0x8(%r15), %xmm1
movss %xmm1, 0x8(%r14)
movq 0x18(%rsp), %rax
movss %xmm2, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: lastFileNum
int lastFileNum(const char *folderName) {
  int num=-1;
  tinydir_dir dir;

  if(tinydir_open(&dir, folderName) != -1) {
    while(dir.has_next) {
      tinydir_file file;
      tinydir_readfile(&dir,&file);
      int fnLen=strlen(file.name);

      char numStr[256];
      numStr[0]='\0';
      memset(numStr,0,256);
      if(!file.is_dir) {
        int i,j=0;

        for(i=0;i<fnLen;i++) {

          // if(file.name[i]=='0' && j==0) {
          //   j++;
          // } else
          if(file.name[i]>='0' && file.name[i]<='9') {
            numStr[j++]=file.name[i];

          } else if(j>0) {
            break;
          }
        }

        if(numStr[0]!='\0') {
          // printf("%s\n",numStr);
          int num2=atoi(numStr);

          if(num2 > num) {
            num=num2;
          }
        }
      }

      tinydir_next(&dir);
    }

    tinydir_close(&dir);
  }

  return num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x22c8, %rsp           # imm = 0x22C8
movq %rdi, %rsi
leaq 0x100(%rsp), %rdi
callq 0x411f9c
pushq $-0x1
popq %rbx
cmpl $-0x1, %eax
je 0x413f3d
leaq 0x2128(%rsp), %r14
leaq 0x100(%rsp), %r15
leaq 0x1128(%rsp), %r12
movq %rsp, %r13
cmpl $0x0, 0x1100(%rsp)
je 0x413f30
movq %r15, %rdi
movq %r12, %rsi
callq 0x412225
movq %r14, %rdi
callq 0x401140
movq %rax, %rbp
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x4010e8
cmpl $0x0, 0x2230(%rsp)
jne 0x413f23
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
xorl %ecx, %ecx
cmpq %rax, %rbp
je 0x413f10
movb 0x2128(%rsp,%rax), %dl
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0x413f07
movslq %ecx, %rsi
incl %ecx
movb %dl, (%rsp,%rsi)
jmp 0x413f0b
testl %ecx, %ecx
jg 0x413f10
incq %rax
jmp 0x413ee8
cmpb $0x0, (%rsp)
je 0x413f23
movq %r13, %rdi
callq 0x422e30
cmpl %ebx, %eax
cmovgl %eax, %ebx
movq %r15, %rdi
callq 0x4121d0
jmp 0x413ea2
leaq 0x100(%rsp), %rdi
callq 0x412060
movl %ebx, %eax
addq $0x22c8, %rsp           # imm = 0x22C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: EncodeFloatRGBA
void EncodeFloatRGBA(float v,float *out) {
//from aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
  // 255^0 = 1
  // 255^1 = 255
  // 255^2 = 65025
  // 255^3 = 16581375

  float enc[4];

  //vec4 enc = vec4(1.0, 255.0, 65025.0, 16581375.0) * v;
  enc[0]=v;
  enc[1]=v*255.0f;
  enc[2]=v*65025.0f;
  enc[3]=v*16581375.0f;

  //enc-=floor(enc); //enc = frac(enc);
  enc[0]-=floor(enc[0]);
  enc[1]-=floor(enc[1]);
  enc[2]-=floor(enc[2]);
  enc[3]-=floor(enc[3]);

  //enc -= enc.yzww * vec4(1.0/255.0,1.0/255.0,1.0/255.0,0.0);
  out[0]=enc[0]-enc[1]*(1.0f/255.0f);
  out[1]=enc[1]-enc[2]*(1.0f/255.0f);
  out[2]=enc[2]-enc[3]*(1.0f/255.0f);
  out[3]=enc[3];
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1      # xmm1 = xmm1[0,0],xmm0[0,0]
mulps 0xc13ab(%rip), %xmm1    # 0x4d5360
movaps %xmm1, 0x20(%rsp)
movss 0xc1346(%rip), %xmm1    # 0x4d5308
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
callq 0x401150
movaps 0x10(%rsp), %xmm1
subss %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x401150
movss 0xc(%rsp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movaps 0x20(%rsp), %xmm0
callq 0x401150
movaps %xmm0, 0x30(%rsp)
movaps 0x20(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
callq 0x401150
movaps 0x30(%rsp), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps 0x20(%rsp), %xmm1
subps %xmm2, %xmm1
movaps 0x10(%rsp), %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movaps 0xc133a(%rip), %xmm0    # 0x4d5370
mulps %xmm1, %xmm0
addps %xmm2, %xmm0
movlps %xmm0, (%rbx)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss 0xc12c1(%rip), %xmm0    # 0x4d530c
movss 0xc(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rbx)
movss %xmm2, 0xc(%rbx)
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: encodeNorSphereMap
void encodeNorSphereMap(const float *n,float *out) {
  //from aras-p.info/texts/CompactNormalStorage.html
  float f = sqrt(8.0f*n[2]+8.0f);
  out[0]=n[0]/ f + 0.5f;
  out[1]=n[1]/ f + 0.5f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movss 0xbf83a(%rip), %xmm1    # 0x4d3920
movss 0x8(%rdi), %xmm0
mulss %xmm1, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x414101
sqrtss %xmm0, %xmm0
jmp 0x414106
callq 0x415a50
movss (%r14), %xmm1
divss %xmm0, %xmm1
movss 0xbe365(%rip), %xmm2    # 0x4d247c
addss %xmm2, %xmm1
movss %xmm1, (%rbx)
movss 0x4(%r14), %xmm1
divss %xmm0, %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: decodeNorSphereMap
void decodeNorSphereMap(const float *enc,float *out) {
  float fenc[2];
  fenc[0]=enc[0]*4.0f-2.0f;
  fenc[1]=enc[1]*4.0f-2.0f;

  float f = fenc[0]*fenc[0]+fenc[1]+fenc[1];
  float g = sqrtf(1.0f-f/4.0f);


  out[0]=fenc[0]*g;
  out[1]=fenc[1]*g;
  out[2]=1.0f-f/2.0f;

}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd (%rdi), %xmm2
mulps 0xc1224(%rip), %xmm2    # 0x4d5380
addps 0xc122d(%rip), %xmm2    # 0x4d5390
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0     # xmm0 = xmm0[1,1],xmm2[1,1]
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
addss %xmm0, %xmm3
addss %xmm0, %xmm3
movss 0xc1197(%rip), %xmm0    # 0x4d5318
mulss %xmm3, %xmm0
addss 0xbe2d3(%rip), %xmm0    # 0x4d2460
movq %rsi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x41419e
sqrtss %xmm0, %xmm0
jmp 0x4141b5
movaps %xmm2, 0x10(%rsp)
movaps %xmm3, (%rsp)
callq 0x415a50
movaps (%rsp), %xmm3
movaps 0x10(%rsp), %xmm2
unpcklps %xmm0, %xmm0            # xmm0 = xmm0[0,0,1,1]
mulps %xmm0, %xmm2
mulss 0xbe2c5(%rip), %xmm3    # 0x4d2488
movlps %xmm2, (%rbx)
addss 0xbe292(%rip), %xmm3    # 0x4d2460
movss %xmm3, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: bitmapFlipVertical
void bitmapFlipVertical(unsigned char *data,int c, int w, int h) {
  unsigned char *tmp;
  tmp=(unsigned char*)malloc(w*c);
  int i;

  for(i=0;i<h/2;i++) {
    int x=i*c*w;
    int y=(h-1-i)*c*w;
    memcpy(tmp,&data[x],c*w);
    memcpy(&data[x],&data[y],c*w);
    memcpy(&data[y],tmp,c*w);
  }

  free(tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdi, 0x10(%rsp)
imull %edx, %esi
movslq %esi, %r15
movq %r15, %rdi
callq 0x442160
movq %rax, 0x8(%rsp)
pushq $0x2
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
cltq
movq %rax, 0x18(%rsp)
decl %ebx
imull %r15d, %ebx
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x8(%rsp), %r12
cmpq 0x18(%rsp), %rax
jge 0x414278
movslq %r14d, %r14
movq 0x10(%rsp), %rbp
leaq (%r14,%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rax, 0x20(%rsp)
callq 0x401060
movslq %ebx, %rbx
addq %rbx, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x401060
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x401060
movq 0x20(%rsp), %rax
incq %rax
subl %r15d, %ebx
addl %r15d, %r14d
jmp 0x414220
movq 0x8(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4424a0
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/utils.c
// Function: stringFromFile
bool stringFromFile(const char *fn, char **str) {
  FILE *file;
  unsigned int dataSize;

  //open file
  file = fopen(fn, "rb");

  if(!file) {
    return false;
  }

  //get data size
  fseek(file,0L,SEEK_END);
  dataSize = ftell(file);
  fseek(file,0L,SEEK_SET);

  //
  (*str)=(char*)malloc(dataSize+1);

  //read data
  (*str)[dataSize]=0;//is not already null terminated?
  fread((*str),1,dataSize,file);

  //close file
  fclose(file);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0xbf788(%rip), %rsi     # 0x4d3a27
callq 0x42bb40
movq %rax, %rbx
testq %rax, %rax
je 0x4142f9
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x42fdc0
movq %rbx, %rdi
callq 0x42bd40
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42fdc0
leal 0x1(%r15), %edi
callq 0x442160
movq %rax, (%r14)
movl %r15d, %edx
movb $0x0, (%rax,%rdx)
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rcx
callq 0x42bc40
movq %rbx, %rdi
callq 0x42b410
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: fatal_error
void
fatal_error(char *s)
{
	fprintf(stderr, "%s,%d: error: %s\n", filename, lineno, s);
	fprintf(stderr, "line: %s\n", ibuf);

	if (misra_rules > 1) show_violations();
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %r8
movq 0xccfc(%rip), %rbx      # 0x10ff8
movq (%rbx), %rdi
movq 0xce0a(%rip), %rdx      # 0x11110
movl 0xdb84(%rip), %ecx      # 0x11e90
leaq 0x5f12(%rip), %rsi      # 0xa225
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rdi
leaq 0x9ed8(%rip), %rsi      # 0xe1fc
leaq 0x10155(%rip), %rdx     # 0x14480
xorl %eax, %eax
callq 0x4150
cmpl $0x2, 0xdb5b(%rip)      # 0x11e94
jl 0x4340
callq 0x9ce9
pushq $0x1
popq %rdi
callq 0x41b0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: emalloc
char *
emalloc(int n)
{	char *ptr;
#ifdef PC
	int m = n%sizeof(unsigned long);
	if (m != 0) n += sizeof(unsigned long)-m;
#endif
	ptr = (char *) malloc(n);
	if (!ptr) fatal_error("out of memory");
	memset(ptr, 0, n);
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rsi
pushq $0x1
popq %rdi
callq 0x4130
testq %rax, %rax
je 0x435e
popq %rbp
retq
leaq 0x5ed2(%rip), %rdi      # 0xa237
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: skipwhite
void
skipwhite(void)
{
	white = 0;
	while (*nowc == ' ' || *nowc == '\t')
	{	if (*nowc == ' ')
			white++;
		else
			white += 8-((nowc - lbuf + white)%8);
		nowc++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andl $0x0, 0xd949(%rip)      # 0x11e98
movq 0xd94a(%rip), %rcx      # 0x11ea0
leaq 0x1(%rcx), %rsi
leaq 0xd94f(%rip), %rax      # 0x11eb0
subq %rax, %rcx
xorl %edi, %edi
movabsq $0x8, %r8
movzbl -0x1(%rsi), %eax
cmpl $0x9, %eax
je 0x4582
cmpl $0x20, %eax
jne 0x45a8
incl %edi
jmp 0x4593
movslq %edi, %rdi
leaq (%rcx,%rdi), %rax
cqto
idivq %r8
subl %edx, %edi
addl $0x8, %edi
movl %edi, 0xd8ff(%rip)      # 0x11e98
movq %rsi, 0xd900(%rip)      # 0x11ea0
incq %rsi
incq %rcx
jmp 0x4570
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: show_line
void
show_line(int d, FILE *fd)
{
	if (verbose)
		fprintf(fd, "[%d:%d] ", level, not_printing[level]);
	if (numbered)
		fprintf(fd, "%s,%d: ", filename, lineno);
	if (verbose || explanations
	|| (!d && !not_printing[level]))	/* not a directive */
	{	prep_line(start);
		fprintf(fd, "%s", lbuf);
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x0, 0xe8f2(%rip)      # 0x12eb0
je 0x45e2
movslq 0xe8ed(%rip), %rdx      # 0x12eb4
leaq 0xe8f2(%rip), %rax      # 0x12ec0
movl (%rax,%rdx,4), %ecx
leaq 0x5d1f(%rip), %rsi      # 0xa2f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0xecd7(%rip)      # 0x132c0
je 0x4609
movq 0xcb1e(%rip), %rdx      # 0x11110
movl 0xd898(%rip), %ecx      # 0x11e90
leaq 0x5d01(%rip), %rsi      # 0xa300
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0xe8a0(%rip)      # 0x12eb0
jne 0x4634
testb $0x1, 0xecab(%rip)      # 0x132c4
jne 0x4634
testl %r14d, %r14d
jne 0x464f
movslq 0xe88d(%rip), %rax      # 0x12eb4
leaq 0xe892(%rip), %rcx      # 0x12ec0
cmpl $0x0, (%rcx,%rax,4)
jne 0x464f
movq 0xec8d(%rip), %rdi      # 0x132c8
callq 0x465e
leaq 0xd869(%rip), %rdi      # 0x11eb0
movq %rbx, %rsi
callq 0x40f0
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4110
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: prep_line
static void
prep_line(TS *from)
{	char tmp[1024];
	TS *n;
	int i;
	static int saw_else_last;

	strcpy(lbuf, "");
	for (n = from; n; n = n->nxt)
	{	for (i = n->space; i > 0; i--)
			strcat(lbuf, " ");

		switch (n->tok) {
		case NAME:
			strcat(lbuf, n->name);
			saw_else_last = (strcmp(n->name, "else") == 0);
			break;
		case VAL:
			sprintf(tmp, "%d", n->val);
			strcat(lbuf, tmp);
			saw_else_last = 0;
			break;
		case ECHAR:
			strcat(lbuf, "\\");
			saw_else_last = 0;
			/* fall thru */
		case CHAR:
			sprintf(tmp, "%c", n->val);
			strcat(lbuf, tmp);

			if (saw_else_last && n->val == ';')
			fprintf(stderr, "%s,%d: 'else' is followed by ';'\n",
				filename, lineno);
			saw_else_last = 0;
			break;
		case TPASTE:
			strcat(lbuf, "##");
			break;
		default:
			fprintf(stderr, "saw: ");
			tokfull(n, stderr);
			fprintf(stderr, "\n");
			fatal_error("unknown token");
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movb $0x0, 0xd834(%rip)      # 0x11eb0
leaq 0xd82d(%rip), %r14      # 0x11eb0
leaq 0x59fe(%rip), %r15      # 0xa088
leaq -0x430(%rbp), %r12
testq %rbx, %rbx
je 0x47bc
movl 0x10(%rbx), %r13d
testl %r13d, %r13d
jle 0x46b7
movq %r14, %rdi
callq 0x40a0
movw $0x20, (%rax,%r14)
decl %r13d
jmp 0x469e
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x46f8
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4190
movq 0x8(%rbx), %rdi
leaq 0x961a(%rip), %rsi      # 0xdcfb
callq 0x4140
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0xec09(%rip)      # 0x132fc
jmp 0x478c
cmpl $0x20, %eax
jne 0x47ce
movq %r14, %rdi
callq 0x40a0
movw $0x2323, (%rax,%r14)    # imm = 0x2323
movb $0x0, 0x2(%rax,%r14)
jmp 0x478c
movq %r14, %rdi
callq 0x40a0
movw $0x5c, (%rax,%r14)
andl $0x0, 0xebce(%rip)      # 0x132fc
movb $0x1, %r13b
jmp 0x475f
movl 0x4(%rbx), %edx
movq %r12, %rdi
leaq 0x9168(%rip), %rsi      # 0xd8a8
xorl %eax, %eax
callq 0x41a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4190
jmp 0x4785
cmpl $0x0, 0xeba1(%rip)      # 0x132fc
sete %r13b
movb 0x4(%rbx), %al
movb %al, -0x430(%rbp)
movb $0x0, -0x42f(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4190
testb %r13b, %r13b
jne 0x4785
cmpl $0x3b, 0x4(%rbx)
je 0x4795
andl $0x0, 0xeb70(%rip)      # 0x132fc
movq 0x28(%rbx), %rbx
jmp 0x4691
movq 0xc85c(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq 0xc96a(%rip), %rdx      # 0x11110
movl 0xd6e4(%rip), %ecx      # 0x11e90
leaq 0x90f8(%rip), %rsi      # 0xd8ab
xorl %eax, %eax
callq 0x4150
jmp 0x4785
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc823(%rip), %r14      # 0x10ff8
movq (%r14), %rcx
leaq 0x90f1(%rip), %rdi      # 0xd8d0
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x41c0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5a09
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x4110
leaq 0x90cf(%rip), %rdi      # 0xd8d6
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: release_all
static void
release_all(TS *s)
{
	if (!s) return;
	release_all(s->nxt);
	release_ml(s->ml);
	s->nxt = free_ts;
	free_ts = s;
}

// Assembly:
testq %rdi, %rdi
je 0x4e61
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x4e29
movq 0x18(%rbx), %rdi
callq 0x5a9c
movq 0xe4b0(%rip), %rax      # 0x13300
movq %rax, 0x28(%rbx)
movq %rbx, 0xe4a5(%rip)      # 0x13300
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: preconfigure
void
preconfigure(void)
{	int i;

	for (i = 0; cnfm[i] != NULL; i++)
	{	strcpy(ibuf, cnfm[i]);
		preprocess();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xbb8a(%rip), %r14      # 0x11200
leaq 0xee03(%rip), %rbx      # 0x14480
movq (%r14), %rsi
testq %rsi, %rsi
je 0x5698
movq %rbx, %rdi
callq 0x4070
callq 0x480c
addq $0x8, %r14
jmp 0x567d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: add_def
static void
add_def(char *s)	/* e.g., NAME or NAME=... */
{	char *p, *z;

	z = emalloc(strlen(s)+1);
	strcpy(z, s);

	if ((p = strchr(z, '=')) != NULL)
	{	*p = '\0';
		newmacro(z);
		*p++ = '=';
		white = 0;
		if (isdigit(*p))
			addbody(VAL, atoi(p));
		else
		{	addbody(NAME, 0);
			cb->name = p;
		}
	} else
		newmacro(z);

	closemacro();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4348
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
pushq $0x3d
popq %rsi
movq %r14, %rdi
callq 0x40b0
testq %rax, %rax
je 0x5983
movq %rax, %rbx
movq %rax, %r15
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0x63e6
incq %rbx
movb $0x3d, (%r15)
andl $0x0, 0xc540(%rip)      # 0x11e98
callq 0x41e0
movq (%rax), %rax
movsbq 0x1(%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x598d
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x64dd
movq 0xd9b3(%rip), %rax      # 0x13330
movq %rbx, 0x8(%rax)
jmp 0x599f
movq %r14, %rdi
callq 0x63e6
jmp 0x599f
movq %rbx, %rdi
callq 0x4180
pushq $0x4
popq %rdi
movl %eax, %esi
callq 0x64dd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6518
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: rm_def
static void
rm_def(char *s)
{	MD *m, *lm = (MD *) 0;

	for (m = md; m; lm = m, m = m->nxt)
		if (strcmp(m->nm, s) == 0)
			break;
	if (m)
	{	if (!lm)
			md = m->nxt;
		else
			lm->nxt = m->nxt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd956(%rip), %rax      # 0x13318
xorl %r14d, %r14d
movq (%rax), %r15
testq %r15, %r15
je 0x59fe
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x4140
testl %eax, %eax
je 0x59e5
leaq 0x28(%r15), %rax
movq %r15, %r14
jmp 0x59c5
leaq 0x28(%r14), %rax
testq %r14, %r14
movq 0x28(%r15), %rcx
leaq 0xd921(%rip), %rdx      # 0x13318
cmovneq %rax, %rdx
movq %rcx, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: tokfull
static void
tokfull(TS *n, FILE *fd)
{
	tokname(n->tok, fd);
	switch (n->tok) {
	case NAME: fprintf(fd, " <%s> ", n->name); break;
	case CHAR: fprintf(fd, " <%c> ", n->val); break;
	case ECHAR: fprintf(fd, " <\\%c> ", n->val); break;
	case VAL: fprintf(fd, " <%d> ", n->val); break;
	default: fprintf(fd, " <?> "); break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x436a
movl (%r14), %eax
decl %eax
cmpl $0x3, %eax
ja 0x5a83
leaq 0x46d2(%rip), %rcx      # 0xa100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rdx
leaq 0x7ea2(%rip), %rsi      # 0xd8e4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
movl 0x4(%r14), %edx
leaq 0x7e97(%rip), %rsi      # 0xd8f2
jmp 0x5a75
movl 0x4(%r14), %edx
leaq 0x7e92(%rip), %rsi      # 0xd8fa
jmp 0x5a75
movl 0x4(%r14), %edx
leaq 0x7e76(%rip), %rsi      # 0xd8eb
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
leaq 0x7e77(%rip), %rdi      # 0xd901
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: release_ml
static void
release_ml(ML *m)
{
	if (!m) return;
	release_ml(m->nxt);
	m->nxt = free_ml;
	free_ml = m;
}

// Assembly:
testq %rdi, %rdi
je 0x5acb
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x5a9c
movq 0xd84e(%rip), %rax      # 0x13308
movq %rax, 0x8(%rbx)
movq %rbx, 0xd843(%rip)      # 0x13308
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: new_inl
static TS *
new_inl(Tokvals t)
{	TS *n;

	if (free_ts)
	{	n = free_ts;
		free_ts = free_ts->nxt;
		memset(n, 0, sizeof(TS));
	} else
		n = (TS *) emalloc(sizeof(TS));
	n->tok = t;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xd825(%rip), %rax      # 0x13300
testq %rax, %rax
je 0x5afb
movq 0x28(%rax), %rcx
movq %rcx, 0xd815(%rip)      # 0x13300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x5b03
pushq $0x30
popq %rdi
callq 0x4348
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: find_delimiter
static char *
find_delimiter(char *d, char *t)
{	char *p, *q, *r, *s;

zz:	p = strstr(t, d);
	if (!p) return NULL;

	s = t;
yy:	q = strchr(s, '"');

	if (q && q <= p)	/* in string */
	{	/* real string delimiter? */
		if (strncmp(q-1, "'\"'", 3) == 0
		||  strncmp(q-2, "'\\\"'", 4) == 0)
		{	s = q+2;
			goto yy; /* no, try again */
		}
		q++;	/* presumably real string */
xx:		r = strchr(q, '"');	/* find closing quote */
		if (!r) fatal_error("unterminated string");

		if (*(r-1) == '\\') { q++; goto xx; }

		if (r < p)	/* string ends before comment starts */
		{	s = r+1;
			goto yy; /* find another */
		} else	/* yes we're in a string */
		{	t = r;	/* find another delimiter */
			goto zz;
	}	}

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
pushq $0x22
popq %r14
pushq $0x4
popq %r12
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x41d0
movq %rax, %r13
testq %rax, %rax
je 0x5bb3
movq %r15, %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x40b0
testq %rax, %rax
je 0x5bb3
movq %rax, %rbx
cmpq %r13, %rax
ja 0x5bb3
cmpb $0x27, -0x1(%rbx)
jne 0x5b69
cmpb $0x22, (%rbx)
jne 0x5b69
cmpb $0x27, 0x1(%rbx)
je 0x5b80
leaq -0x2(%rbx), %rdi
leaq 0x7dae(%rip), %rsi      # 0xd922
movq %r12, %rdx
callq 0x4060
testl %eax, %eax
jne 0x5b86
addq $0x2, %rbx
jmp 0x5b40
incq %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x40b0
testq %rax, %rax
je 0x5bc5
movq %rax, %r15
incq %rbx
cmpb $0x5c, -0x1(%rax)
je 0x5b89
cmpq %r13, %r15
jae 0x5b29
incq %r15
jmp 0x5b3d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7d5b(%rip), %rdi      # 0xd927
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_lineno
static void
do_lineno(TS *d)
{
	if (d->tok != VAL)
	{
bad:		fprintf(stderr, "%s,%d: warning: malformed directive %s",
			filename, lineno, ibuf);
		return;
	}
	lineno = d->val;

	d = d->nxt;
	if (!d || d->tok != CHAR || d->val != '\"')
		return;	/* no filename */

	d = d->nxt;
	if (!d || d->tok != NAME)
		goto bad;

	filename = d->name;

	d = d->nxt;
	if (!d || d->tok != CHAR || d->val != '\"')
		goto bad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x4, (%rdi)
jne 0x5c26
movl 0x4(%rdi), %ecx
movl %ecx, 0xc2ad(%rip)      # 0x11e90
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x5c24
cmpl $0x2, (%rax)
jne 0x5c24
cmpl $0x22, 0x4(%rax)
jne 0x5c24
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x5c2c
cmpl $0x1, (%rax)
jne 0x5c2c
movq 0x8(%rax), %rdx
movq %rdx, 0xb500(%rip)      # 0x11110
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x5c2c
cmpl $0x2, (%rax)
jne 0x5c2c
cmpl $0x22, 0x4(%rax)
jne 0x5c2c
popq %rbp
retq
movl 0xc264(%rip), %ecx      # 0x11e90
movq 0xb3c5(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq 0xb4d3(%rip), %rdx      # 0x11110
leaq 0x7dc3(%rip), %rsi      # 0xda07
leaq 0xe835(%rip), %r8       # 0x14480
xorl %eax, %eax
popq %rbp
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_ifdef
static void
do_ifdef(TS *s)
{	MD *m;

	if (s->tok != NAME)
		fatal_error("expecting name after #ifdef or #ifndef");
		
	if (level >= 255) 
		fatal_error("ifdefs nested too deep");

	m = is_macro(s->name);
	add_tag(s, m);

	not_printing[++level] = (m == NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, (%rdi)
jne 0x5e56
cmpl $0xff, 0xd0a3(%rip)     # 0x12eb4
jge 0x5e62
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6350
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6386
xorl %eax, %eax
testq %r14, %r14
sete %al
movslq 0xd078(%rip), %rcx      # 0x12eb4
leaq 0x1(%rcx), %rdx
movl %edx, 0xd06e(%rip)      # 0x12eb4
leaq 0xd073(%rip), %rdx      # 0x12ec0
movl %eax, 0x4(%rdx,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7c7a(%rip), %rdi      # 0xdad7
callq 0x42ec
leaq 0x7c95(%rip), %rdi      # 0xdafe
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_undef
static void
do_undef(TS *s)
{
	if (s->tok != NAME)
		fatal_error("expect name after #undef");

	if (misra_rules
	&&  BlockDepth > 0)
		m_rule(19, 5, "#undef within block scope");

	if (misra_rules)
		m_rule(19, 6, "#undef");

	rm_def(s->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x1, (%rdi)
jne 0x629f
movq %rdi, %rbx
movl 0xbc3f(%rip), %eax      # 0x11e94
testl %eax, %eax
je 0x627a
cmpl $0x0, 0xd0b0(%rip)      # 0x13310
jle 0x627a
leaq 0x7a62(%rip), %rdx      # 0xdccb
pushq $0x13
popq %rdi
pushq $0x5
popq %rsi
callq 0x9bc0
movl 0xbc1a(%rip), %eax      # 0x11e94
testl %eax, %eax
je 0x6290
leaq 0x7a3f(%rip), %rdx      # 0xdcc4
pushq $0x13
popq %rdi
pushq $0x6
popq %rsi
callq 0x9bc0
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x59ae
leaq 0x7a0c(%rip), %rdi      # 0xdcb2
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_else
static void
do_else(TS *unused)
{
	if (level <= 0) fatal_error("unmatched #else");

	if (not_printing[level] < 2)
		not_printing[level] = 1 - not_printing[level];
	/* if it's 3 it remains unchanged */
}

// Assembly:
movslq 0xcbb5(%rip), %rax      # 0x12eb4
testq %rax, %rax
jle 0x631c
leaq 0xcbb5(%rip), %rcx      # 0x12ec0
movl (%rcx,%rax,4), %edx
cmpl $0x1, %edx
jg 0x631b
pushq $0x1
popq %rsi
subl %edx, %esi
movl %esi, (%rcx,%rax,4)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x79c9(%rip), %rdi      # 0xdcf0
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: is_macro
static MD *
is_macro(char *s)
{	MD *m;

	for (m = md; m; m = m->nxt)
		if (strcmp(m->nm, s) == 0)
			return m;

	return (MD *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xcfb7(%rip), %rbx      # 0x13318
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x637e
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
je 0x637e
addq $0x28, %rbx
jmp 0x6361
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: add_tag
static void
add_tag(TS *ni, MD *m)
{	ML *ml;

	for (ml = ni->ml; ml; ml = ml->nxt)
		if (ml->m == m)
			return;

	if (free_ml)
	{	ml = free_ml;
		free_ml = free_ml->nxt;
		memset(ml, 0, sizeof(ML));
	} else
		ml = (ML *) emalloc(sizeof(ML));
	ml->m = m;
	ml->nxt = ni->ml;
	ni->ml = ml;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rbx
movq %rbx, %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x63ad
leaq 0x8(%rcx), %rax
cmpq %r14, (%rcx)
jne 0x639a
jmp 0x63e1
movq 0xcf54(%rip), %rax      # 0x13308
testq %rax, %rax
je 0x63cc
movq 0x8(%rax), %rcx
movq %rcx, 0xcf44(%rip)      # 0x13308
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x63d4
pushq $0x10
popq %rdi
callq 0x4348
movq %r14, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: newmacro
static void
newmacro(char *s)
{	MD *m;

	m = (MD *) emalloc(sizeof(MD));
	m->nm = emalloc(strlen(s)+1);
	strcpy(m->nm, s);
	m->ln = lineno;
	m->fnm = emalloc(strlen(filename)+1);
	strcpy(m->fnm, filename);
	m->nxt = md;
	md = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x4348
movq %rax, %rbx
movq %r14, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4348
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4070
movl 0xba71(%rip), %eax      # 0x11e90
movl %eax, 0x8(%rbx)
movq 0xace7(%rip), %rdi      # 0x11110
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4348
movq %rax, 0x10(%rbx)
movq 0xaccf(%rip), %rsi      # 0x11110
movq %rax, %rdi
callq 0x4070
movq 0xcec8(%rip), %rax      # 0x13318
movq %rax, 0x28(%rbx)
movq %rbx, 0xcebd(%rip)      # 0x13318
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: scan_args
static int
scan_args(char *s)
{	ARGS *an;
	int i;

	for (i = 0, an = ca; an; i++, an = an->nxt)
		if (strcmp(s, an->nm) == 0
		|| (strcmp(s, "__VA_ARGS__") == 0
		&&  strcmp(an->nm, "...") == 0))
			return i;

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0xceae(%rip), %r12      # 0x13328
leaq 0x7721(%rip), %r15      # 0xdba2
movq (%r12), %r12
testq %r12, %r12
je 0x64cb
movq (%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x4140
testl %eax, %eax
je 0x64c7
movq %r14, %rdi
movq %r15, %rsi
callq 0x4140
testl %eax, %eax
jne 0x64bf
movq %r13, %rdi
leaq 0x7497(%rip), %rsi      # 0xd94d
callq 0x4140
testl %eax, %eax
je 0x64c7
incl %ebx
addq $0x8, %r12
jmp 0x6481
movl %ebx, %eax
jmp 0x64ce
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: addbody
static void
addbody(Tokvals tok, int v)
{	TS *b;

	b = new_inl(tok);
	b->space = white;
	b->val = v;
	b->nxt = cb;
	if (cb) cb->prv = b;
	cb = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
callq 0x5acc
movl 0xb9a8(%rip), %ecx      # 0x11e98
movl %ecx, 0x10(%rax)
movl %ebx, 0x4(%rax)
movq 0xce33(%rip), %rcx      # 0x13330
movq %rcx, 0x28(%rax)
testq %rcx, %rcx
je 0x650a
movq %rax, 0x20(%rcx)
movq %rax, 0xce1f(%rip)      # 0x13330
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: nested
static void
nested(char *s)
{	int i;
	for (i = 0; i < Enesting; i++)
		printf("\t");
	printf("%s", s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x9
popq %r14
cmpl 0xca8f(%rip), %r15d     # 0x14340
jge 0x78c0
movl %r14d, %edi
callq 0x4040
incl %r15d
jmp 0x78aa
leaq 0x6164(%rip), %rdi      # 0xda2b
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40c0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: cpy_orig
static TS *
cpy_orig(TS *or)
{	TS *nw = (TS *) 0;
	ML *ml;

	if (or != (TS *) 0)
	{	nw = cpy_inl(or, (TS *) 0);
		nw->ml = (ML *) 0;
		for (ml = or->ml; ml; ml = ml->nxt)
			add_tag(nw, ml->m);

		nw->nxt = cpy_orig(or->nxt);
		if (nw->nxt)
			nw->nxt->prv = nw;
	}

	return nw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7931
movq %rdi, %r14
xorl %esi, %esi
callq 0x7c77
movq %rax, %rbx
andq $0x0, 0x18(%rax)
leaq 0x18(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x7919
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6386
addq $0x8, %r15
jmp 0x7900
movq 0x28(%r14), %rdi
callq 0x78db
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x7933
movq %rbx, 0x20(%rax)
jmp 0x7933
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: cpy_inl
static TS *
cpy_inl(TS *s, TS *prv)
{	TS *n;
	n = new_inl(s->tok);
	n->val = s->val;
	n->name = s->name;
	n->space = s->space;
	n->ml = s->ml;
	n->prv = prv;
	if (prv) prv->nxt = n;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x5acc
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%r14), %ecx
movl %ecx, 0x10(%rax)
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rbx, 0x20(%rax)
testq %rbx, %rbx
je 0x7cb6
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: hunt_param
static ARL *
hunt_param(MD *m, TS *b)
{	ARL  *ap;	/* actual */
	ARGS *fp;	/* formal */
	int i = 0, j = 0;
	int n = b->val;	/* nr of param in formal param list */
#ifdef DEBUG
	TS *x; printf("\n");
#endif
	for (ap = saa; ap; ap = ap->nxt)
	{	i++;	/* count actual params */
#ifdef DEBUG
		printf("actual %d ", i);
		for (x = ap->al; x; x = x->nxt)
			printf("%s ", x->name);
		if (i==n) printf("<<--%s", b->name);
			printf("\n");
#endif
	}

	for (fp = m->arg; fp; fp = fp->nxt)
	{	j++;	/* count formal params */
#ifdef DEBUG
		printf("formal %d %s\n", j, fp->nm);
#endif
	}

	if (strcmp(b->name, "__VA_ARGS__") == 0)
		n = j-1;	/* last formal */

	for (i = 0, ap = saa; ap; i++, ap = ap->nxt)
		if (i == n) break;	/* nth param in actual param list */

	if (!ap) fatal_error("did not find param");

	return ap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x4(%rsi), %ebx
leaq 0xc67c(%rip), %rax      # 0x14348
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x7ccc
addq $0x18, %rdi
pushq $-0x1
popq %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7cf1
addq $0x8, %rdi
incl %r14d
jmp 0x7ce0
movq 0x8(%rsi), %rdi
leaq 0x5ea6(%rip), %rsi      # 0xdba2
callq 0x4140
testl %eax, %eax
cmovel %r14d, %ebx
leaq 0xc63a(%rip), %rax      # 0x14348
movq (%rax), %rax
subl $0x1, %ebx
setb %cl
testq %rax, %rax
je 0x7d26
testb %cl, %cl
jne 0x7d26
addq $0x10, %rax
jmp 0x7d0e
testq %rax, %rax
je 0x7d30
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x62bc(%rip), %rdi      # 0xdff3
callq 0x42ec
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: add_inl
static void
add_inl(Tokvals tt, int v, char *nm, int sp, int reuse)
{	TS *ni;

	ni = new_inl(tt);
	ni->val = v;

	if (reuse)
		ni->name  = nm;
	else
	{	ni->name = emalloc(strlen(nm)+1);
		strcpy(ni->name, nm);
	}
	ni->space = sp;

	if (lst) lst->nxt = ni;
	ni->prv = lst;
	if (!frst) frst = ni;
	lst = ni;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r13d
callq 0x5acc
movq %rax, %rbx
movl %r13d, 0x4(%rax)
testl %r12d, %r12d
je 0x7d6d
movq %r15, 0x8(%rbx)
jmp 0x7d8c
movq %r15, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4348
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4070
movl %r14d, 0x10(%rbx)
movq 0xc5c1(%rip), %rax      # 0x14358
testq %rax, %rax
je 0x7da0
movq %rbx, 0x28(%rax)
movq %rax, 0x20(%rbx)
cmpq $0x0, 0xc5b4(%rip)      # 0x14360
jne 0x7db5
movq %rbx, 0xc5ab(%rip)      # 0x14360
movq %rbx, 0xc59c(%rip)      # 0x14358
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: stringify
static char *
stringify(TS *s, TS *f)
{	static char m[128];
	static char p[128];
	char *q;
	int i = 0;

	if (!s) return "";

	p[0] = m[1] = '\0';

	if (s)
	switch (s->tok) {
	case NAME:
		for (q = s->name; *q != '\0'; q++)
		{	if (*q == '\\'
			||  *q == '"')
				strcat(p, "\\");
			m[0] = *q;
			strcat(p, m);
		}
		break;

	case VAL:
		sprintf(p, "%d", s->val);
		break;

	case CHAR:
		if (s->val != '"')
		{	sprintf(p, "%c", s->val);  
			break;
		}
		/* else fall thru */
	case ECHAR:
		sprintf(p, "\\%c", s->val);
		break;

	default: break;
	}

	if (s != f)	/* not for first arg */
	for (i = 0; i < s->space; i++)
		m[i] = ' ';

	m[i] = '\0';
	strcat(m, p);

	return m;
}

// Assembly:
testq %rdi, %rdi
je 0x7e63
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0xc581(%rip)       # 0x14371
movb %al, 0xc5fa(%rip)       # 0x143f0
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x7ea3
leaq 0x2326(%rip), %rcx      # 0xa130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %r13
leaq 0xc5d2(%rip), %r15      # 0x143f0
leaq 0xc54b(%rip), %r12      # 0x14370
movzbl (%r13), %eax
cmpl $0x22, %eax
je 0x7e3a
cmpl $0x5c, %eax
je 0x7e3a
testl %eax, %eax
jne 0x7e4d
jmp 0x7ea3
movq %r15, %rdi
callq 0x40a0
movw $0x5c, (%rax,%r15)
movb (%r13), %al
movb %al, 0xc51d(%rip)       # 0x14370
movq %r15, %rdi
movq %r12, %rsi
callq 0x4190
incq %r13
jmp 0x7e25
leaq 0x672a(%rip), %rax      # 0xe594
retq
movl 0x4(%rbx), %edx
jmp 0x7e8e
movl 0x4(%rbx), %edx
leaq 0xc576(%rip), %rdi      # 0x143f0
leaq 0x5a27(%rip), %rsi      # 0xd8a8
jmp 0x7e9c
movl 0x4(%rbx), %eax
cmpl $0x22, %eax
jne 0x7ee8
pushq $0x22
popq %rdx
leaq 0xc55b(%rip), %rdi      # 0x143f0
leaq 0x616a(%rip), %rsi      # 0xe006
xorl %eax, %eax
callq 0x41a0
xorl %eax, %eax
cmpq %r14, %rbx
je 0x7ec3
leaq 0xc4bf(%rip), %rcx      # 0x14370
movslq 0x10(%rbx), %rdx
cmpq %rdx, %rax
jge 0x7ec3
movb $0x20, (%rax,%rcx)
incq %rax
jmp 0x7eb1
leaq 0xc4a6(%rip), %rdi      # 0x14370
movb $0x0, (%rax,%rdi)
leaq 0xc51b(%rip), %rsi      # 0x143f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4190
movb %al, 0xc502(%rip)       # 0x143f0
movb $0x0, 0xc4fc(%rip)      # 0x143f1
jmp 0x7ea3
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: string_size
static int
string_size(TS *s)
{	int cnt, v;

	if (!s) return 0;

	cnt = s->space+1;
	switch (s->tok) {
	case NAME:	cnt = strlen(s->name);
			break;
	case VAL:	for (v = s->val; v >= 10; v /= 10)
				cnt++;
			break;
	case ECHAR:	cnt++; /* fall thru */
	default:	break;
	}

	return cnt+string_size(s->nxt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0xa
popq %r15
testq %r14, %r14
je 0x7f55
movl (%r14), %edx
movl 0x10(%r14), %eax
leal 0x1(%rax), %ecx
cmpl $0x4, %edx
je 0x7f43
cmpl $0x3, %edx
je 0x7f36
cmpl $0x1, %edx
jne 0x7f3b
movq 0x8(%r14), %rdi
callq 0x40a0
movq %rax, %rcx
jmp 0x7f3b
addl $0x2, %eax
movl %eax, %ecx
movq 0x28(%r14), %r14
addl %ecx, %ebx
jmp 0x7f0a
movl 0x4(%r14), %eax
cmpl $0xa, %eax
jl 0x7f3b
incl %ecx
xorl %edx, %edx
divl %r15d
jmp 0x7f47
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: add_sysdir
void
add_sysdir(char *s)
{	ARGS *inc;

	if (!s || strlen(s) < 2) return;

	for (inc = sysdirs; inc; inc = inc->nxt)
		if (strcmp(s, inc->nm) == 0)
			return;

	inc = (ARGS *) emalloc(sizeof(ARGS));
	inc->nm = (char *) emalloc(strlen(s)+1);
	strcpy(inc->nm, s);
	inc->nxt = sysdirs;
	sysdirs = inc;
}

// Assembly:
testq %rdi, %rdi
je 0x7fe1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x40a0
cmpq $0x2, %rax
jb 0x7fdd
leaq 0xc4eb(%rip), %r14      # 0x14470
movq (%r14), %r14
testq %r14, %r14
je 0x7fa2
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4140
addq $0x8, %r14
testl %eax, %eax
jne 0x7f85
jmp 0x7fdd
pushq $0x10
popq %rdi
callq 0x4348
movq %rax, %r14
movq %rbx, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4348
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
movq 0xc49e(%rip), %rax      # 0x14470
movq %rax, 0x8(%r14)
movq %r14, 0xc493(%rip)      # 0x14470
popq %rbx
popq %r14
popq %rbp
retq