LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x41560c
cmpl $-0x1, %eax
je 0x4176df
cmpl $0x0, 0x1100(%rsp)
je 0x4176e6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x2128(%rsp), %r14
leaq 0x100(%rsp), %r15
leaq 0x1128(%rsp), %r12
movq %rsp, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x4158b2
movq %r14, %rdi
callq 0x401138
movq %rax, %rbp
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x4010e0
cmpl $0x0, 0x2230(%rsp)
sete %al
testl %ebp, %ebp
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4176c7
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %ecx, %ecx
movb 0x2128(%rsp,%rax), %dl
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0x4176a8
movslq %ecx, %rsi
incl %ecx
movb %dl, (%rsp,%rsi)
jmp 0x4176ac
testl %ecx, %ecx
jg 0x4176b4
incq %rax
cmpq %rax, %rbp
jne 0x41768e
cmpb $0x0, (%rsp)
je 0x4176c7
movq %r13, %rdi
callq 0x426590
cmpl %ebx, %eax
cmovgl %eax, %ebx
movq %r15, %rdi
callq 0x415858
cmpl $0x0, 0x1100(%rsp)
jne 0x417648
jmp 0x4176eb
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x4176f8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x100(%rsp), %rdi
callq 0x4156d8
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_O3/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 0xc1d80(%rip), %xmm1    # 0x4d94f0
movaps %xmm1, 0x20(%rsp)
movss 0xc1d1f(%rip), %xmm1    # 0x4d949c
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
callq 0x401148
movaps 0x10(%rsp), %xmm1
subss %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x401148
movss 0xc(%rsp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movaps 0x20(%rsp), %xmm0
callq 0x401148
movaps %xmm0, 0x30(%rsp)
movaps 0x20(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
callq 0x401148
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 0xc1d0f(%rip), %xmm0    # 0x4d9500
mulps %xmm1, %xmm0
addps %xmm2, %xmm0
movlps %xmm0, (%rbx)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss 0xc1c9a(%rip), %xmm0    # 0x4d94a0
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_O3/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 0xc0093(%rip), %xmm1    # 0x4d7934
movss 0x8(%rdi), %xmm0
mulss %xmm1, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4178bc
sqrtss %xmm0, %xmm0
jmp 0x4178c1
callq 0x4191b0
movss (%r14), %xmm1
divss %xmm0, %xmm1
movss 0xbebb6(%rip), %xmm2    # 0x4d6488
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_O3/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 0xc1bf9(%rip), %xmm2    # 0x4d9510
addps 0xc1c02(%rip), %xmm2    # 0x4d9520
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 0xc1b70(%rip), %xmm0    # 0x4d94ac
mulss %xmm3, %xmm0
addss 0xbffd8(%rip), %xmm0    # 0x4d7920
movq %rsi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x417959
sqrtss %xmm0, %xmm0
jmp 0x417970
movaps %xmm2, 0x10(%rsp)
movaps %xmm3, (%rsp)
callq 0x4191b0
movaps (%rsp), %xmm3
movaps 0x10(%rsp), %xmm2
unpcklps %xmm0, %xmm0            # xmm0 = xmm0[0,0,1,1]
mulps %xmm0, %xmm2
mulss 0xbeb16(%rip), %xmm3    # 0x4d6494
movlps %xmm2, (%rbx)
addss 0xbff97(%rip), %xmm3    # 0x4d7920
movss %xmm3, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc001f(%rip), %rsi     # 0x4d7a77
callq 0x42f2a0
movq %rax, %rbx
testq %rax, %rax
je 0x417ab6
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x433520
movq %rbx, %rdi
callq 0x42f4a0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x433520
leal 0x1(%r15), %edi
callq 0x4458c0
movq %rax, (%r14)
movl %r15d, %edx
movb $0x0, (%rax,%rdx)
movl $0x1, %esi
movq %rax, %rdi
movq %rbx, %rcx
callq 0x42f3a0
movq %rbx, %rdi
callq 0x42eb70
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd5bc(%rip), %rbx      # 0x11ff8
movq (%rbx), %rdi
movq 0xd6ca(%rip), %rdx      # 0x12110
movl 0xe444(%rip), %ecx      # 0x12e90
leaq 0x67d2(%rip), %rsi      # 0xb225
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rdi
leaq 0xa798(%rip), %rsi      # 0xf1fc
leaq 0x10a15(%rip), %rdx     # 0x15480
xorl %eax, %eax
callq 0x4150
cmpl $0x2, 0xe41b(%rip)      # 0x12e94
jl 0x4a80
callq 0xa428
movl $0x1, %edi
callq 0x41b0
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
callq 0x4130
testq %rax, %rax
je 0x4aa2
popq %rbp
retq
leaq 0x678e(%rip), %rdi      # 0xb237
callq 0x4a2c
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe22f(%rip)      # 0x12e98
movq 0xe230(%rip), %rax      # 0x12ea0
leaq 0x1(%rax), %rcx
leaq 0xe235(%rip), %rdx      # 0x12eb0
subq %rdx, %rax
xorl %edx, %edx
movzbl -0x1(%rcx), %esi
cmpl $0x9, %esi
je 0x4c92
cmpl $0x20, %esi
jne 0x4cc1
incl %edx
jmp 0x4cac
movslq %edx, %rdx
leaq (%rax,%rdx), %rsi
leal 0x7(%rsi), %edi
testq %rsi, %rsi
cmovnsl %esi, %edi
andl $-0x8, %edi
subl %esi, %edi
addl %edi, %edx
addl $0x8, %edx
movl %edx, 0xe1e6(%rip)      # 0x12e98
movq %rcx, 0xe1e7(%rip)      # 0x12ea0
incq %rcx
incq %rax
jmp 0x4c80
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xf1d9(%rip)      # 0x13eb0
je 0x4cfb
movslq 0xf1d4(%rip), %rdx      # 0x13eb4
leaq 0xf1d9(%rip), %rax      # 0x13ec0
movl (%rax,%rdx,4), %ecx
leaq 0x6606(%rip), %rsi      # 0xb2f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0xf5be(%rip)      # 0x142c0
je 0x4d22
movq 0xd405(%rip), %rdx      # 0x12110
movl 0xe17f(%rip), %ecx      # 0x12e90
leaq 0x65e8(%rip), %rsi      # 0xb300
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0xf187(%rip)      # 0x13eb0
jne 0x4d4d
testb $0x1, 0xf592(%rip)      # 0x142c4
jne 0x4d4d
testl %r14d, %r14d
jne 0x4d68
movslq 0xf174(%rip), %rax      # 0x13eb4
leaq 0xf179(%rip), %rcx      # 0x13ec0
cmpl $0x0, (%rcx,%rax,4)
jne 0x4d68
movq 0xf574(%rip), %rdi      # 0x142c8
callq 0x4d79
leaq 0xe150(%rip), %rdi      # 0x12eb0
movq %rbx, %rsi
callq 0x40f0
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4110
// File: /workspace/github_c_makefile_star2_O3/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
movb $0x0, 0xe11c(%rip)      # 0x12eb0
testq %rdi, %rdi
je 0x4eca
movq %rdi, %rbx
leaq 0xe109(%rip), %r14      # 0x12eb0
leaq 0x62da(%rip), %r15      # 0xb088
leaq -0x430(%rbp), %r12
movl 0x10(%rbx), %r13d
testl %r13d, %r13d
jle 0x4dd9
incl %r13d
movq %r14, %rdi
callq 0x40a0
movw $0x20, (%rax,%r14)
decl %r13d
cmpl $0x1, %r13d
ja 0x4dc1
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x4e1a
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4190
movq 0x8(%rbx), %rdi
leaq 0x9ef8(%rip), %rsi      # 0xecfb
callq 0x4140
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0xf4e7(%rip)      # 0x142fc
jmp 0x4eb4
cmpl $0x20, %eax
jne 0x4edc
movq %r14, %rdi
callq 0x40a0
movw $0x2323, (%rax,%r14)    # imm = 0x2323
movb $0x0, 0x2(%rax,%r14)
jmp 0x4eb4
movq %r14, %rdi
callq 0x40a0
movw $0x5c, (%rax,%r14)
movl $0x0, 0xf4a9(%rip)      # 0x142fc
movb $0x1, %r13b
jmp 0x4e84
movl 0x4(%rbx), %edx
movq %r12, %rdi
leaq 0x9a43(%rip), %rsi      # 0xe8a8
xorl %eax, %eax
callq 0x41a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4190
jmp 0x4eaa
cmpl $0x0, 0xf47c(%rip)      # 0x142fc
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 0x4eaa
cmpl $0x3b, 0x4(%rbx)
je 0x4ec3
movl $0x0, 0xf448(%rip)      # 0x142fc
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x4db5
jmp 0x4eca
callq 0x4200
jmp 0x4eaa
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x422a
// File: /workspace/github_c_makefile_star2_O3/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 0x5516
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x54de
movq 0x18(%rbx), %rdi
callq 0x6176
movq 0xedfb(%rip), %rax      # 0x14300
movq %rax, 0x28(%rbx)
movq %rbx, 0xedf0(%rip)      # 0x14300
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0xc408(%rip), %rsi      # 0x12200
testq %rsi, %rsi
je 0x5e2f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xc3fd(%rip), %r14      # 0x12208
leaq 0xf66e(%rip), %rbx      # 0x15480
movq %rbx, %rdi
callq 0x4070
callq 0x4ee4
movq (%r14), %rsi
addq $0x8, %r14
testq %rsi, %rsi
jne 0x5e12
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4a8a
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
movq %r14, %rdi
movl $0x3d, %esi
callq 0x40b0
testq %rax, %rax
je 0x6046
movq %rax, %rbx
movq %rax, %r15
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0x6b20
incq %rbx
movb $0x3d, (%r15)
movl $0x0, 0xce7f(%rip)      # 0x12e98
callq 0x41e0
movq (%rax), %rax
movsbq 0x1(%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x6050
movl $0x1, %edi
xorl %esi, %esi
callq 0x6c20
movq 0xe2f0(%rip), %rax      # 0x14330
movq %rbx, 0x8(%rax)
jmp 0x6064
movq %r14, %rdi
callq 0x6b20
jmp 0x6064
movq %rbx, %rdi
callq 0x4180
movl $0x4, %edi
movl %eax, %esi
callq 0x6c20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c8c
// File: /workspace/github_c_makefile_star2_O3/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 0xe294(%rip), %r14      # 0x14318
testq %r14, %r14
je 0x60d4
movq %rdi, %rbx
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4140
testl %eax, %eax
je 0x60b8
movq %r14, %r15
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x60d4
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4140
testl %eax, %eax
jne 0x609b
jmp 0x60bb
xorl %r15d, %r15d
leaq 0x28(%r15), %rax
testq %r15, %r15
movq 0x28(%r14), %rcx
leaq 0xe24b(%rip), %rdx      # 0x14318
cmovneq %rax, %rdx
movq %rcx, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4aae
movl (%r14), %eax
decl %eax
cmpl $0x3, %eax
ja 0x6159
leaq 0x4ffc(%rip), %rcx      # 0xb100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rdx
leaq 0x87cc(%rip), %rsi      # 0xe8e4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
movl 0x4(%r14), %edx
leaq 0x87c1(%rip), %rsi      # 0xe8f2
jmp 0x614b
movl 0x4(%r14), %edx
leaq 0x87bc(%rip), %rsi      # 0xe8fa
jmp 0x614b
movl 0x4(%r14), %edx
leaq 0x87a0(%rip), %rsi      # 0xe8eb
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
leaq 0x87a1(%rip), %rdi      # 0xe901
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O3/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 0x61a5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6176
movq 0xe174(%rip), %rax      # 0x14308
movq %rax, 0x8(%rbx)
movq %rbx, 0xe169(%rip)      # 0x14308
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x41d0
testq %rax, %rax
je 0x627a
movq %rax, %r15
leaq 0x874a(%rip), %r12      # 0xe922
movq %rbx, %rdi
movl $0x22, %esi
callq 0x40b0
testq %rax, %rax
je 0x6275
movq %rax, %r13
cmpq %r15, %rax
ja 0x6275
cmpb $0x27, -0x1(%r13)
jne 0x620b
cmpb $0x22, (%r13)
jne 0x620b
cmpb $0x27, 0x1(%r13)
je 0x624e
leaq -0x2(%r13), %rdi
movl $0x4, %edx
movq %r12, %rsi
callq 0x4060
testl %eax, %eax
je 0x624e
incq %r13
movq %r13, %rdi
movl $0x22, %esi
callq 0x40b0
testq %rax, %rax
je 0x628b
movq %rax, %rbx
incq %r13
cmpb $0x5c, -0x1(%rax)
je 0x6223
cmpq %r15, %rbx
jae 0x6257
incq %rbx
movq %rbx, %r13
jmp 0x6252
addq $0x2, %r13
movq %r13, %rdi
jmp 0x61db
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41d0
movq %rax, %r15
testq %rax, %rax
movl $0x0, %eax
jne 0x61d8
jmp 0x627c
movq %r15, %rax
jmp 0x627c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8695(%rip), %rdi      # 0xe927
callq 0x4a2c
// File: /workspace/github_c_makefile_star2_O3/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 0x62ec
movl 0x4(%rdi), %ecx
movl %ecx, 0xcbe7(%rip)      # 0x12e90
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x62ea
cmpl $0x2, (%rax)
jne 0x62ea
cmpl $0x22, 0x4(%rax)
jne 0x62ea
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x62f2
cmpl $0x1, (%rax)
jne 0x62f2
movq 0x8(%rax), %rdx
movq %rdx, 0xbe3a(%rip)      # 0x12110
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x62f2
cmpl $0x2, (%rax)
jne 0x62f2
cmpl $0x22, 0x4(%rax)
jne 0x62f2
popq %rbp
retq
movl 0xcb9e(%rip), %ecx      # 0x12e90
movq 0xbcff(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xbe0d(%rip), %rdx      # 0x12110
leaq 0x86fd(%rip), %rsi      # 0xea07
leaq 0xf16f(%rip), %r8       # 0x15480
xorl %eax, %eax
popq %rbp
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O3/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 0x6556
cmpl $0xff, 0xd9a3(%rip)     # 0x13eb4
jge 0x6562
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6a8a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6ac2
xorl %eax, %eax
testq %r14, %r14
sete %al
movslq 0xd978(%rip), %rcx      # 0x13eb4
leaq 0x1(%rcx), %rdx
movl %edx, 0xd96e(%rip)      # 0x13eb4
leaq 0xd973(%rip), %rdx      # 0x13ec0
movl %eax, 0x4(%rdx,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x857a(%rip), %rdi      # 0xead7
callq 0x4a2c
leaq 0x8595(%rip), %rdi      # 0xeafe
callq 0x4a2c
// File: /workspace/github_c_makefile_star2_O3/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 0x69fe
movq %rdi, %rbx
movl 0xc4e8(%rip), %eax      # 0x12e94
testl %eax, %eax
je 0x69d5
cmpl $0x0, 0xd959(%rip)      # 0x14310
jle 0x69d5
leaq 0x830b(%rip), %rdx      # 0xeccb
movl $0x13, %edi
movl $0x5, %esi
callq 0xa2f8
movl 0xc4bf(%rip), %eax      # 0x12e94
testl %eax, %eax
je 0x69ef
leaq 0x82e4(%rip), %rdx      # 0xecc4
movl $0x13, %edi
movl $0x6, %esi
callq 0xa2f8
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6073
leaq 0x82ad(%rip), %rdi      # 0xecb2
callq 0x4a2c
// File: /workspace/github_c_makefile_star2_O3/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 0xd47d(%rip), %rax      # 0x13eb4
testq %rax, %rax
jle 0x6a56
leaq 0xd47d(%rip), %rcx      # 0x13ec0
movl (%rcx,%rax,4), %edx
cmpl $0x1, %edx
jg 0x6a55
movl $0x1, %esi
subl %edx, %esi
movl %esi, (%rcx,%rax,4)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x828f(%rip), %rdi      # 0xecf0
callq 0x4a2c
// File: /workspace/github_c_makefile_star2_O3/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 0xd880(%rip), %rbx      # 0x14318
testq %rbx, %rbx
je 0x6ab8
movq %rdi, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
je 0x6aba
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x6aa0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x6ae3
cmpq %r14, (%rax)
je 0x6b1b
movq 0x8(%rax), %rax
jmp 0x6ad3
movq 0xd81e(%rip), %rax      # 0x14308
testq %rax, %rax
je 0x6b02
movq 0x8(%rax), %rcx
movq %rcx, 0xd80e(%rip)      # 0x14308
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x6b0c
movl $0x10, %edi
callq 0x4a8a
movq %r14, (%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x30, %edi
callq 0x4a8a
movq %rax, %rbx
movq %r14, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4a8a
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4070
movl 0xc335(%rip), %eax      # 0x12e90
movl %eax, 0x8(%rbx)
movq 0xb5ab(%rip), %rdi      # 0x12110
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4a8a
movq %rax, 0x10(%rbx)
movq 0xb593(%rip), %rsi      # 0x12110
movq %rax, %rdi
callq 0x4070
movq 0xd78c(%rip), %rax      # 0x14318
movq %rax, 0x28(%rbx)
movq %rbx, 0xd781(%rip)      # 0x14318
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd777(%rip), %r12      # 0x14328
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r12, %r12
je 0x6c11
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x7fdb(%rip), %r15      # 0xeba2
movq (%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x4140
testl %eax, %eax
je 0x6c0f
movq %r14, %rdi
movq %r15, %rsi
callq 0x4140
testl %eax, %eax
jne 0x6bfc
movq %r13, %rdi
leaq 0x7d5a(%rip), %rsi      # 0xe94d
callq 0x4140
testl %eax, %eax
je 0x6c0f
incl %ebx
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x6bc7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6c11
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movq 0xd6cd(%rip), %rax      # 0x14300
testq %rax, %rax
je 0x6c53
movq 0x28(%rax), %rcx
movq %rcx, 0xd6bd(%rip)      # 0x14300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x6c5d
movl $0x30, %edi
callq 0x4a8a
movl %r14d, (%rax)
movl 0xc232(%rip), %ecx      # 0x12e98
movl %ecx, 0x10(%rax)
movl %ebx, 0x4(%rax)
movq 0xd6bd(%rip), %rcx      # 0x14330
movq %rcx, 0x28(%rax)
testq %rcx, %rcx
je 0x6c80
movq %rax, 0x20(%rcx)
movq %rax, 0xd6a9(%rip)      # 0x14330
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xd3f3(%rip)      # 0x15340
jle 0x7f68
xorl %r14d, %r14d
movl $0x9, %edi
callq 0x4040
incl %r14d
cmpl 0xd3da(%rip), %r14d     # 0x15340
jl 0x7f52
leaq 0x6abc(%rip), %rdi      # 0xea2b
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x40c0
// File: /workspace/github_c_makefile_star2_O3/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 0x7fd3
movq %rdi, %r14
xorl %esi, %esi
callq 0x82bd
movq %rax, %rbx
movq $0x0, 0x18(%rax)
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x7fbb
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6ac2
movq 0x8(%r15), %r15
jmp 0x7fa5
movq 0x28(%r14), %rdi
callq 0x7f7d
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x7fd5
movq %rbx, 0x20(%rax)
jmp 0x7fd5
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r15d
movq 0xc029(%rip), %rax      # 0x14300
testq %rax, %rax
je 0x82f7
movq 0x28(%rax), %rcx
movq %rcx, 0xc019(%rip)      # 0x14300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x8301
movl $0x30, %edi
callq 0x4a8a
movl %r15d, (%rax)
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 0x832f
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcffd(%rip), %rax      # 0x15348
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x834b
movq 0x18(%rdi), %rax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x836f
movq 0x8(%rax), %rax
incl %r14d
jmp 0x8361
movq 0x8(%rsi), %rdi
leaq 0x6828(%rip), %rsi      # 0xeba2
callq 0x4140
testl %eax, %eax
cmovel %r14d, %ebx
movq 0xcfbc(%rip), %rax      # 0x15348
testq %rax, %rax
sete %cl
je 0x83b0
testl %ebx, %ebx
je 0x83b0
decl %ebx
movq 0x10(%rax), %rax
subl $0x1, %ebx
setb %dl
testq %rax, %rax
sete %cl
je 0x83b0
testb %dl, %dl
je 0x839a
testb %cl, %cl
jne 0x83b9
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6c33(%rip), %rdi      # 0xeff3
callq 0x4a2c
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdx, %r15
movl %esi, %r13d
movl %edi, %r14d
movq 0xbf1a(%rip), %rbx      # 0x14300
testq %rbx, %rbx
je 0x8406
movq 0x28(%rbx), %rax
movq %rax, 0xbf0a(%rip)      # 0x14300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x8417
movl $0x30, %edi
movl %ecx, %ebx
callq 0x4a8a
movl %ebx, %ecx
movq %rax, %rbx
movl %r14d, (%rbx)
movl %r13d, 0x4(%rbx)
testl %r12d, %r12d
je 0x8429
movq %r15, 0x8(%rbx)
jmp 0x844e
movq %r15, %rdi
movl %ecx, %r14d
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4a8a
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4070
movl %r14d, %ecx
movl %ecx, 0x10(%rbx)
movq 0xcf00(%rip), %rax      # 0x15358
testq %rax, %rax
je 0x8461
movq %rbx, 0x28(%rax)
movq %rax, 0x20(%rbx)
cmpq $0x0, 0xcef3(%rip)      # 0x15360
jne 0x8476
movq %rbx, 0xceea(%rip)      # 0x15360
movq %rbx, 0xcedb(%rip)      # 0x15358
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8524
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, 0xcec0(%rip)       # 0x15371
movb %al, 0xcf39(%rip)       # 0x153f0
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x8566
leaq 0x2c65(%rip), %rcx      # 0xb130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %r13
leaq 0xcf11(%rip), %r15      # 0x153f0
leaq 0xce8a(%rip), %r12      # 0x15370
movzbl (%r13), %eax
cmpl $0x22, %eax
je 0x84fb
cmpl $0x5c, %eax
je 0x84fb
testl %eax, %eax
jne 0x850e
jmp 0x8566
movq %r15, %rdi
callq 0x40a0
movw $0x5c, (%rax,%r15)
movb (%r13), %al
movb %al, 0xce5c(%rip)       # 0x15370
movq %r15, %rdi
movq %r12, %rsi
callq 0x4190
incq %r13
jmp 0x84e6
leaq 0x7069(%rip), %rax      # 0xf594
retq
movl 0x4(%rbx), %edx
jmp 0x8551
movl 0x4(%rbx), %edx
leaq 0xceb5(%rip), %rdi      # 0x153f0
leaq 0x6366(%rip), %rsi      # 0xe8a8
jmp 0x855f
movl 0x4(%rbx), %eax
movl $0x22, %edx
cmpl $0x22, %eax
jne 0x85b3
leaq 0xce98(%rip), %rdi      # 0x153f0
leaq 0x6aa7(%rip), %rsi      # 0xf006
xorl %eax, %eax
callq 0x41a0
cmpq %r14, %rbx
je 0x858c
cmpl $0x0, 0x10(%rbx)
jle 0x858c
xorl %eax, %eax
leaq 0xcdf6(%rip), %rcx      # 0x15370
movb $0x20, (%rax,%rcx)
incq %rax
movslq 0x10(%rbx), %rdx
cmpq %rdx, %rax
jl 0x857a
jmp 0x858e
xorl %eax, %eax
leaq 0xcddb(%rip), %rdi      # 0x15370
movb $0x0, (%rax,%rdi)
leaq 0xce50(%rip), %rsi      # 0x153f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4190
movb %al, 0xce37(%rip)       # 0x153f0
movb $0x0, 0xce31(%rip)      # 0x153f1
jmp 0x8566
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x8630
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
movl (%r14), %edx
movl 0x10(%r14), %ecx
leal 0x1(%rcx), %eax
cmpl $0x4, %edx
je 0x8607
cmpl $0x3, %edx
je 0x8600
cmpl $0x1, %edx
jne 0x8623
movq 0x8(%r14), %rdi
callq 0x40a0
jmp 0x8623
addl $0x2, %ecx
movl %ecx, %eax
jmp 0x8623
movl 0x4(%r14), %ecx
cmpl $0xa, %ecx
jl 0x8623
incl %eax
movl %ecx, %edx
imulq %r15, %rdx
shrq $0x23, %rdx
cmpl $0x63, %ecx
movl %edx, %ecx
ja 0x8610
addl %eax, %ebx
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x85dc
jmp 0x8632
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x86bc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x40a0
cmpq $0x2, %rax
jb 0x86b8
movq 0xce0f(%rip), %r14      # 0x15470
testq %r14, %r14
je 0x867b
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x86b8
movq 0x8(%r14), %r14
jmp 0x8661
movl $0x10, %edi
callq 0x4a8a
movq %rax, %r14
movq %rbx, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4a8a
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
movq 0xcdc3(%rip), %rax      # 0x15470
movq %rax, 0x8(%r14)
movq %r14, 0xcdb8(%rip)      # 0x15470
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: need_more
void
need_more(void)
{
	if (fgets(ibuf, MAXIN, mfd) == NULL)
		fatal_error("gh_cpp: unexpected eof");
	delta++;
	trimline(ibuf);
	/* should check if the line ends in a \\ */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xdd91(%rip), %rdx      # 0x16480
leaq 0xcd8a(%rip), %rdi      # 0x15480
movl $0x1000, %esi           # imm = 0x1000
callq 0x4120
testq %rax, %rax
jne 0x8711
leaq 0x6a2b(%rip), %rdi      # 0xf137
callq 0x4a2c
incl 0xdd71(%rip)            # 0x16488
popq %rbp
jmp 0x871a
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: trimline
static int
trimline(char *b)
{	int len;

	len = strlen(b);
	if (len >= MAXIN) fatal_error("input line too long");

	while (len > 1
	&& (b[len-2] == ' '
	||  b[len-2] == '\t'))
	{	b[len-2] = '\n';
		b[len-1] = '\0';
		len--;
	}

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xcd58(%rip), %r14      # 0x15480
movq %r14, %rdi
callq 0x40a0
movq %rax, %rbx
cmpl $0x1000, %ebx           # imm = 0x1000
jl 0x8749
leaq 0x6b15(%rip), %rdi      # 0xf257
callq 0x4a2c
jmp 0x874e
cmpl $0x2, %ebx
jl 0x877e
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movzbl -0x2(%rbx,%r14), %eax
cmpl $0x20, %eax
je 0x8764
cmpl $0x9, %eax
jne 0x877e
movw $0xa, -0x2(%rbx,%r14)
leaq -0x1(%rbx), %rax
cmpq $0x2, %rbx
movq %rax, %rbx
jg 0x8754
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: search_sys
static int
search_sys(ARGS *n, char *f)
{	char *s;
	FILE *nfd;

	if (!n) return 0;

	if (search_sys(n->nxt, f))
		return 1;

	s = (char *) emalloc(strlen(f)+strlen(n->nm)+1+1);
	sprintf(s, "%s/%s", n->nm, f);

	if (misra_rules)
	{	if (strcmp(s, "malloc.h") == 0)
			m_rule(20, 4, "<malloc.h>");
		else if (strcmp(s, "signal.h") == 0)
			m_rule(20, 8, "<signal.h>");
		else if (strcmp(s, "stdio.h") == 0)
			m_rule(20, 9, "<stdio.h>");
		else if (strcmp(s, "time.h") == 0)
			m_rule(20, 12, "<time.h>");
	}

	if ((nfd = fopen(s, "r")) == NULL)
	{	free(s);
		return 0;
	}
	if (verbose>1) printf("/**** #include: %s ****/\n", s);

	fclose(nfd);
	do_file(filename, lineno, s);
	free(s);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8f19
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
callq 0x8e3c
movl $0x1, %r14d
testl %eax, %eax
jne 0x8fc2
movq %r15, %rdi
callq 0x40a0
movq %rax, %rbx
movq (%r12), %rdi
callq 0x40a0
leal (%rax,%rbx), %edi
addl $0x2, %edi
callq 0x4a8a
movq %rax, %rbx
movq (%r12), %rdx
leaq 0x62e8(%rip), %rsi      # 0xf182
xorl %r14d, %r14d
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x41a0
leaq 0x9fe3(%rip), %rax      # 0x12e94
cmpl $0x0, (%rax)
je 0x8f5d
leaq 0x63aa(%rip), %rsi      # 0xf26b
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8f21
leaq 0x63ab(%rip), %rsi      # 0xf27f
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8f34
leaq 0x63ac(%rip), %rsi      # 0xf293
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8f47
leaq 0x63ab(%rip), %rsi      # 0xf2a5
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
jne 0x8f5d
leaq 0x639f(%rip), %rdx      # 0xf2ac
movl $0x14, %edi
movl $0xc, %esi
jmp 0x8f58
xorl %r14d, %r14d
jmp 0x8fc2
leaq 0x634c(%rip), %rdx      # 0xf274
movl $0x14, %edi
movl $0x4, %esi
jmp 0x8f58
leaq 0x634d(%rip), %rdx      # 0xf288
movl $0x14, %edi
movl $0x8, %esi
jmp 0x8f58
leaq 0x634d(%rip), %rdx      # 0xf29b
movl $0x14, %edi
movl $0x9, %esi
callq 0xa2f8
leaq 0x3510(%rip), %rsi      # 0xc474
movq %rbx, %rdi
callq 0x4170
testq %rax, %rax
je 0x8fba
movq %rax, %r15
leaq 0xaf35(%rip), %rax      # 0x13eb0
cmpl $0x2, (%rax)
jl 0x8f91
leaq 0x6201(%rip), %rdi      # 0xf188
movq %rbx, %rsi
xorl %eax, %eax
callq 0x40c0
movq %r15, %rdi
callq 0x4090
leaq 0x9170(%rip), %rax      # 0x12110
movq (%rax), %rdi
leaq 0x9ee6(%rip), %rax      # 0x12e90
movl (%rax), %esi
movq %rbx, %rdx
callq 0x8a31
movl $0x1, %r14d
movq %rbx, %rdi
callq 0x4030
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: hexa
int
hexa(char *s)
{	int x = 0;
	int cnt = 0;

	for ( ; *s != '\'' && *s != '\0'; s++)
	{	cnt++;
		x = 16*x + *s;
		switch (*s) {
		case '0': case '1': case '2':
		case '3': case '4': case '5':
		case '6': case '7': case '8':
		case '9':
			x -= '0';
			break;
		case 'a': case 'b': case 'c':
		case 'd': case 'e': case 'f':
			x -= 'a' + 10;
			break;
		case 'A': case 'B': case 'C':
		case 'D': case 'E': case 'F':
			x -= 'A' + 10;
			break;
		default:
			fatal_error("bad hexadecimal char constant");
	}	}
	if (cnt == 0)
		fprintf(stderr, "%s,%d: warning, \\x with no hex digits\n",
			filename, lineno);


	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x6415(%rip), %r15      # 0xf400
movl $0x3ff, %r13d           # imm = 0x3FF
movl $0x7e0000, %ecx         # imm = 0x7E0000
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
xorl %ebx, %ebx
movzbl (%r14,%r12), %eax
testl %eax, %eax
je 0x9060
cmpl $0x27, %eax
je 0x9060
movsbl %al, %eax
shll $0x4, %ebx
addl %eax, %ebx
movzbl %al, %eax
addl $-0x30, %eax
cmpl $0x36, %eax
ja 0x9047
btq %rax, %r13
jb 0x903a
btq %rax, %rcx
jb 0x903f
btq %rax, %rdx
jae 0x9047
addl $-0x6b, %ebx
jmp 0x9042
addl $-0x30, %ebx
jmp 0x9042
addl $-0x4b, %ebx
incq %r12
jmp 0x9002
movq %r15, %rdi
callq 0x4a2c
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
movl $0x7e0000, %ecx         # imm = 0x7E0000
jmp 0x9042
testl %r12d, %r12d
je 0x9076
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x46ef
jmp 0x9065
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: octal
int
octal(char *s)
{	int x = 0;
	int cnt = 0;

	for ( ; *s != '\'' && *s != '\0'; s++)
	{	if (++cnt > 3)
		{	x = (x << 8) + *s;
			continue;	/* octal sequence has only 3 significant digits */
		}
		x = 8*x + *s;
		switch (*s) {
		case '0': case '1': case '2':
		case '3': case '4': case '5':
		case '6': case '7': 
			x -= '0';
			break;
		default:
			fprintf(stderr, "saw character '%c'\n", *s);
			fatal_error("bad octal char constant");
	}	}

	if (cnt > 3)
		fprintf(stderr, "%s,%d: warning, multi-byte character constant\n",
			filename, lineno);

	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x90c7
cmpl $0x27, %eax
je 0x90c7
movsbl %al, %edi
cmpl $0x3, %r15d
jb 0x90ad
shll $0x8, %ebx
addl %edi, %ebx
jmp 0x90bb
leal (%rdi,%rbx,8), %ebx
movl %edi, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x90c0
addl $-0x30, %ebx
incq %r15
jmp 0x908f
callq 0x474f
jmp 0x90bb
cmpl $0x4, %r15d
jae 0x90da
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x471f
jmp 0x90cd