LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: enlarge_alnpts
static int enlarge_alnpts(_Work_Data *work, int newmax)
{ void *vec;
  int   max;

  max = ((int) (newmax*1.2)) + 10000;
  vec = Realloc(work->alnpts,max,"Enlarging point vector");
  if (vec == NULL)
    EXIT(1);
  work->alnmax = max;
  work->alnpts = vec;
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0x10644(%rip), %xmm1    # 0x26010
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0x10c73(%rip), %rdx     # 0x26662
callq 0x1aa80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15a09
movl $0x1, %edi
callq 0x2290
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: enlarge_trace
static int enlarge_trace(_Work_Data *work, int newmax)
{ void *vec;
  int   max;

  max = ((int) (newmax*1.2)) + 10000;
  vec = Realloc(work->trace,max,"Enlarging trace vector");
  if (vec == NULL)
    EXIT(1);
  work->tramax = max;
  work->trace  = vec;
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0xf214(%rip), %xmm1     # 0x26010
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0xf873(%rip), %rdx      # 0x26692
callq 0x1aa80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16e39
movl $0x1, %edi
callq 0x2290
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: hamming
static inline int hamming(char *a, char *b, int n)
{ int h, i, x, y;

  h = 0;
  for (i = 0; i < n; i++)
    { x = *a++;
      if (x == 4)
        break;
      y = *b++;
      if (x != y)
        { if (y == 4)
            break;
          else
            h += 1;
        }
    }
  return (h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1a87f
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jne 0x1a842
jmp 0x1a87f
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x1a872
cmpl $0x4, -0x24(%rbp)
jne 0x1a867
jmp 0x1a87f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a872
jmp 0x1a874
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a81d
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: snake
static inline int snake(char *a, char *b)
{ int i, x;

  for (i = 0; 1; i++)
    { x = *a++;
      if (x == 4)
        break;
      if (x != *b++)
        break;
    }
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x1a8ab
jmp 0x1a8f0
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jne 0x1a8c8
jmp 0x1a8f0
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1a8e3
jmp 0x1a8f0
jmp 0x1a8e5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a8a3
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: rsnake
static inline int rsnake(char *a, char *b)
{ int i, x;

  for (i = 0; 1; i++)
    { x = *--a;
      if (x == 4)
        break;
      if (x != *--b)
        break;
    }
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x1a91b
jmp 0x1a962
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl -0x1(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jne 0x1a939
jmp 0x1a962
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movsbl -0x1(%rcx), %ecx
cmpl %ecx, %eax
je 0x1a955
jmp 0x1a962
jmp 0x1a957
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a913
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.6/readfile.c
// Function: read_from_file
char* read_from_file (const char* filename, size_t length)
{
	char* buffer;
	int fd;
	ssize_t bytes_read;
	/* Allocate the buffer. */
	buffer = (char*) malloc (length);
	if (buffer == NULL){
		printf("buffer returns NULL\n");
		return NULL;
	}

	/* Open the file. */
	fd = open (filename, O_RDONLY);
	if (fd == -1) {
		/* open failed. Deallocate buffer before returning. */
		printf("fd == -1\nFallo al abrir\n");
		free (buffer);
		return NULL;
	}
	/* Read the data. */
	bytes_read = read (fd, buffer, length);
	if (bytes_read != length) {
		/* read failed. Deallocate buffer and close fd before returning. */
		printf("bytes_read != length\nFallo al leer\n");
		free (buffer);
		close (fd);
		return NULL;
	}
	/* Everything’s fine. Close the file and return the buffer. */
	close (fd);
	return buffer;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x123f
leaq 0xdd9(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movq $0x0, -0x8(%rbp)
jmp 0x12cd
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x1276
leaq 0xdbd(%rip), %rdi       # 0x2019
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x12cd
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1080
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x12bd
leaq 0xd97(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %edi
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x12cd
movl -0x24(%rbp), %edi
callq 0x1070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.6/readfile.c
// Function: main
int main(){
	char txt[50];
	//para leer cualquier tipo de archivo que se encuentre en la misma ruta que readfile.c
	printf("Introduzca nombre de archivo (default: file.txt)\n");
	scanf(" %s",txt);
	//char dir[50] = "../../src/capitulo_2/2.6/";
	char dir[50] = "./";
		strcat(dir, txt);
	char* file_txt = read_from_file( dir, filebytes(dir));
	printf("%s", file_txt);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xd5d(%rip), %rdi       # 0x2056
movb $0x0, %al
callq 0x1050
leaq -0x40(%rbp), %rsi
leaq 0xd7d(%rip), %rdi       # 0x2088
movb $0x0, %al
callq 0x10e0
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x1060
movb $0x2e, -0x80(%rbp)
movb $0x2f, -0x7f(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10f0
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1390
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x1200
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
leaq 0xd1a(%rip), %rdi       # 0x2089
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.6/readfile.c
// Function: filebytes
size_t filebytes(char* filename){

	size_t fbytes = 0;
	FILE *fich;
	fich = fopen(filename,"r");

	if(fich==NULL){
		return 0;
	}else{
		fseek(fich, 0L, SEEK_END);
		fbytes = ftell(fich);
		printf("file bytes : %zu\n", fbytes);
		fclose(fich);
	}
	return fbytes;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcdd(%rip), %rsi       # 0x208c
callq 0x10d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13c9
movq $0x0, -0x8(%rbp)
jmp 0x140b
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10b0
movq -0x20(%rbp), %rdi
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xc9b(%rip), %rdi       # 0x208e
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/cat.c
// Function: cat
int cat(struct cat_args *args, char *name){
    int fd;
    int c;
    for(int i = 0; i < args->fcount; i++){
        if(!strcmp(args->files[i], "-")){
            fd = STDIN_FILENO;
        }
        else {
            fd = open(args->files[i], O_RDONLY);
            if(fd == -1){
                fprintf(stderr, "%s: %s\n", name, strerror(errno));
                exit(1);
            }
        }
        print_file(fd, args, name);
        close(fd);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1a80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x6d6(%rip), %rsi       # 0x20b4
callq 0x10d0
cmpl $0x0, %eax
jne 0x19f1
movl $0x0, -0x14(%rbp)
jmp 0x1a5a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10f0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1a58
movq 0x25de(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1110
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x657(%rip), %rsi       # 0x209e
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1100
jmp 0x1a5a
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x15b0
movl -0x14(%rbp), %edi
callq 0x1090
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19b7
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/cat.c
// Function: main
int main(int argc, char **argv){
    struct cat_args *args = calloc(1, sizeof(struct cat_args));
    if(args == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    args = parse_arg(args, argc, argv);
    if(argc == 1 || args->fcount == 0){
        args->files[0] = calloc(1, 2 * sizeof(char));
        strcpy(args->files[0], "-");
        args->fcount = 1;
    }
    cat(args, argv[0]);
    free(args->files);
    free(args);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1b0a
movq 0x2531(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1110
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x5a7(%rip), %rsi       # 0x209e
movb $0x0, %al
callq 0x10e0
movl $0x1, -0x4(%rbp)
jmp 0x1b9a
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1220
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0x1b2e
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1b6d
movl $0x1, %edi
movl $0x2, %esi
callq 0x10c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
leaq 0x557(%rip), %rsi       # 0x20b4
callq 0x1050
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x19a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyparsefrom
YY_PARSE(int) YYPARSEFROM(yyrule yystart)
{
  int yyok;
  if (!yybuflen)
    {
      yybuflen= 1024;
      yybuf= malloc(yybuflen);
      yytextlen= 1024;
      yytext= malloc(yytextlen);
      yythunkslen= 32;
      yythunks= malloc(sizeof(yythunk) * yythunkslen);
      yyvalslen= 32;
      yyvals= malloc(sizeof(YYSTYPE) * yyvalslen);
      yybegin= yyend= yypos= yylimit= yythunkpos= 0;
    }
  yybegin= yyend= yypos;
  yythunkpos= 0;
  yyval= yyvals;
  yyok= yystart();
  if (yyok) yyDone();
  yyCommit();
  return yyok;
  (void)yyrefill;
  (void)yymatchDot;
  (void)yymatchChar;
  (void)yymatchString;
  (void)yymatchClass;
  (void)yyDo;
  (void)yyText;
  (void)yyDone;
  (void)yyCommit;
  (void)yyAccept;
  (void)yyPush;
  (void)yyPop;
  (void)yySet;
  (void)yytextmax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xae71(%rip)      # 0xc124
jne 0x1367
movl $0x400, 0xae61(%rip)    # imm = 0x400
movslq 0xae5a(%rip), %rdi      # 0xc124
callq 0x1100
movq %rax, 0xae52(%rip)      # 0xc128
movl $0x400, 0xae50(%rip)    # imm = 0x400
movslq 0xae49(%rip), %rdi      # 0xc130
callq 0x1100
movq %rax, 0xae45(%rip)      # 0xc138
movl $0x20, 0xae43(%rip)     # 0xc140
movslq 0xae3c(%rip), %rax      # 0xc140
imulq $0x18, %rax, %rdi
callq 0x1100
movq %rax, 0xae34(%rip)      # 0xc148
movl $0x20, 0xae32(%rip)     # 0xc150
movslq 0xae2b(%rip), %rdi      # 0xc150
shlq $0x2, %rdi
callq 0x1100
movq %rax, 0xae23(%rip)      # 0xc158
movl $0x0, 0xae21(%rip)      # 0xc160
movl $0x0, 0xae1b(%rip)      # 0xc164
movl $0x0, 0xae15(%rip)      # 0xc168
movl $0x0, 0xae0f(%rip)      # 0xc16c
movl $0x0, 0xae09(%rip)      # 0xc170
movl 0xadfb(%rip), %eax      # 0xc168
movl %eax, 0xadf9(%rip)      # 0xc16c
movl %eax, 0xadf7(%rip)      # 0xc170
movl $0x0, 0xaddd(%rip)      # 0xc160
movq 0xadce(%rip), %rax      # 0xc158
movq %rax, 0xade7(%rip)      # 0xc178
movb $0x0, %al
callq *-0x8(%rbp)
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x13a4
callq 0x13c0
callq 0x1be0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyDone
YY_LOCAL(void) yyDone(void)
{
  int pos;
  for (pos= 0;  pos < yythunkpos;  ++pos)
    {
      yythunk *thunk= &yythunks[pos];
      int yyleng= thunk->end ? yyText(thunk->begin, thunk->end) : thunk->begin;
      yyprintf((stderr, "DO [%d] %p %s\n", pos, thunk->action, yytext));
      thunk->action(yytext, yyleng);
    }
  yythunkpos= 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xad88(%rip), %eax      # 0xc160
jge 0x143f
movq 0xad67(%rip), %rax      # 0xc148
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1411
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1b40
movl %eax, -0x18(%rbp)
jmp 0x141a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xad09(%rip), %rdi      # 0xc138
movl -0x14(%rbp), %esi
callq *%rax
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13cf
movl $0x0, 0xad17(%rip)      # 0xc160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyerror
void yyerror(char *message)
{
  fprintf(stderr, "%s:%d: %s", fileName, lineNumber, message);
  if (yytext[0]) fprintf(stderr, " near token '%s'", yytext);
  if (yypos < yylimit || !feof(input))
    {
      yybuf[yylimit]= '\0';
      fprintf(stderr, " before text \"");
      while (yypos < yylimit)
	{
	  if ('\n' == yybuf[yypos] || '\r' == yybuf[yypos]) break;
	  fputc(yybuf[yypos++], stderr);
	}
      if (yypos == yylimit)
	{
	  int c;
	  while (EOF != (c= fgetc(input)) && '\n' != c && '\r' != c)
	    fputc(c, stderr);
	}
      fputc('\"', stderr);
    }
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xab75(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0xacf3(%rip), %rdx      # 0xc180
movl 0xacf5(%rip), %ecx      # 0xc188
movq -0x8(%rbp), %r8
leaq 0x5cd1(%rip), %rsi      # 0x716f
movb $0x0, %al
callq 0x10c0
movq 0xac8c(%rip), %rax      # 0xc138
cmpb $0x0, (%rax)
je 0x14d0
movq 0xab40(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0xac76(%rip), %rdx      # 0xc138
leaq 0x5cb0(%rip), %rsi      # 0x7179
movb $0x0, %al
callq 0x10c0
movl 0xac92(%rip), %eax      # 0xc168
cmpl 0xac88(%rip), %eax      # 0xc164
jl 0x14f3
movq 0xac33(%rip), %rdi      # 0xc118
callq 0x10d0
cmpl $0x0, %eax
jne 0x1612
movq 0xac2e(%rip), %rax      # 0xc128
movslq 0xac63(%rip), %rcx      # 0xc164
movb $0x0, (%rax,%rcx)
movq 0xaaec(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x5c74(%rip), %rsi      # 0x718a
movb $0x0, %al
callq 0x10c0
movl 0xac45(%rip), %eax      # 0xc168
cmpl 0xac3b(%rip), %eax      # 0xc164
jge 0x1593
movq 0xabf6(%rip), %rax      # 0xc128
movslq 0xac2f(%rip), %rcx      # 0xc168
movsbl (%rax,%rcx), %ecx
movl $0xa, %eax
cmpl %ecx, %eax
je 0x1561
movq 0xabdb(%rip), %rax      # 0xc128
movslq 0xac14(%rip), %rcx      # 0xc168
movsbl (%rax,%rcx), %ecx
movl $0xd, %eax
cmpl %ecx, %eax
jne 0x1563
jmp 0x1593
movq 0xabbe(%rip), %rax      # 0xc128
movl 0xabf8(%rip), %ecx      # 0xc168
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xabed(%rip)      # 0xc168
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
movq 0xaa6f(%rip), %rax      # 0xbff8
movq (%rax), %rsi
callq 0x1090
jmp 0x151d
movl 0xabcf(%rip), %eax      # 0xc168
cmpl 0xabc5(%rip), %eax      # 0xc164
jne 0x15fe
jmp 0x15a3
movq 0xab6e(%rip), %rdi      # 0xc118
callq 0x1080
movl %eax, %edx
movl %edx, -0xc(%rbp)
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %edx, %ecx
movb %al, -0xd(%rbp)
je 0x15df
xorl %eax, %eax
movl $0xa, %ecx
cmpl -0xc(%rbp), %ecx
movb %al, -0xd(%rbp)
je 0x15df
movl $0xd, %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x15e8
jmp 0x15fc
movl -0xc(%rbp), %edi
movq 0xaa06(%rip), %rax      # 0xbff8
movq (%rax), %rsi
callq 0x1090
jmp 0x15a3
jmp 0x15fe
movq 0xa9f3(%rip), %rax      # 0xbff8
movq (%rax), %rsi
movl $0x22, %edi
callq 0x1090
movq 0xa9df(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x7448(%rip), %rsi      # 0x8a6b
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: makeHeader
void makeHeader(char *text)
{
  Header *header= (Header *)malloc(sizeof(Header));
  header->text= strdup(text);
  header->next= headers;
  headers= header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x1100
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0xab1c(%rip), %rcx      # 0xc190
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xab09(%rip)      # 0xc190
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: usage
static void usage(char *name)
{
  version(name);
  fprintf(stderr, "usage: %s [<option>...] [<file>...]\n", name);
  fprintf(stderr, "where <option> can be\n");
  fprintf(stderr, "  -h          print this help information\n");
  fprintf(stderr, "  -o <ofile>  write output to <ofile>\n");
  fprintf(stderr, "  -v          be verbose\n");
  fprintf(stderr, "  -V          print version number and exit\n");
  fprintf(stderr, "if no <file> is given, input is read from stdin\n");
  fprintf(stderr, "if no <ofile> is given, output is written to stdout\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a10
movq 0xa58c(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x579a(%rip), %rsi      # 0x7214
movb $0x0, %al
callq 0x10c0
movq 0xa570(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57a7(%rip), %rsi      # 0x7239
movb $0x0, %al
callq 0x10c0
movq 0xa558(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57a6(%rip), %rsi      # 0x7250
movb $0x0, %al
callq 0x10c0
movq 0xa540(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57b9(%rip), %rsi      # 0x727b
movb $0x0, %al
callq 0x10c0
movq 0xa528(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57c8(%rip), %rsi      # 0x72a2
movb $0x0, %al
callq 0x10c0
movq 0xa510(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57ca(%rip), %rsi      # 0x72bc
movb $0x0, %al
callq 0x10c0
movq 0xa4f8(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57df(%rip), %rsi      # 0x72e9
movb $0x0, %al
callq 0x10c0
movq 0xa4e0(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x57f8(%rip), %rsi      # 0x731a
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyText
YY_LOCAL(int) yyText(int begin, int end)
{
  int yyleng= end - begin;
  if (yyleng <= 0)
    yyleng= 0;
  else
    {
      while (yytextlen < (yyleng - 1))
	{
	  yytextlen *= 2;
	  yytext= realloc(yytext, yytextlen);
	}
      memcpy(yytext, yybuf + begin, yyleng);
    }
  yytext[yyleng]= '\0';
  return yyleng;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x1b66
movl $0x0, -0xc(%rbp)
jmp 0x1bc0
jmp 0x1b68
movl 0xa5c2(%rip), %eax      # 0xc130
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1ba2
movl 0xa5b2(%rip), %eax      # 0xc130
shll %eax
movl %eax, 0xa5aa(%rip)      # 0xc130
movq 0xa5ab(%rip), %rdi      # 0xc138
movslq 0xa59c(%rip), %rsi      # 0xc130
callq 0x1110
movq %rax, 0xa598(%rip)      # 0xc138
jmp 0x1b68
movq 0xa58f(%rip), %rdi      # 0xc138
movq 0xa578(%rip), %rsi      # 0xc128
movslq -0x4(%rbp), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x10e0
movq 0xa571(%rip), %rax      # 0xc138
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyCommit
YY_LOCAL(void) yyCommit()
{
  if ((yylimit -= yypos))
    {
      memmove(yybuf, yybuf + yypos, yylimit);
    }
  yybegin -= yypos;
  yyend -= yypos;
  yypos= yythunkpos= 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xa57e(%rip), %ecx      # 0xc168
movl 0xa574(%rip), %eax      # 0xc164
subl %ecx, %eax
movl %eax, 0xa56c(%rip)      # 0xc164
cmpl $0x0, %eax
je 0x1c21
movq 0xa524(%rip), %rdi      # 0xc128
movq 0xa51d(%rip), %rsi      # 0xc128
movslq 0xa556(%rip), %rax      # 0xc168
addq %rax, %rsi
movslq 0xa548(%rip), %rdx      # 0xc164
callq 0x1120
movl 0xa541(%rip), %ecx      # 0xc168
movl 0xa543(%rip), %eax      # 0xc170
subl %ecx, %eax
movl %eax, 0xa53b(%rip)      # 0xc170
movl 0xa52d(%rip), %ecx      # 0xc168
movl 0xa52b(%rip), %eax      # 0xc16c
subl %ecx, %eax
movl %eax, 0xa523(%rip)      # 0xc16c
movl $0x0, 0xa50d(%rip)      # 0xc160
movl $0x0, 0xa50b(%rip)      # 0xc168
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_grammar
YY_RULE(int) yy_grammar()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "grammar"));  if (!yy__()) goto l111;
  {  int yypos114= yypos, yythunkpos114= yythunkpos;  if (!yy_declaration()) goto l115;  goto l114;
  l115:;	  yypos= yypos114; yythunkpos= yythunkpos114;  if (!yy_definition()) goto l111;
  }
  l114:;	
  l112:;	
  {  int yypos113= yypos, yythunkpos113= yythunkpos;
  {  int yypos116= yypos, yythunkpos116= yythunkpos;  if (!yy_declaration()) goto l117;  goto l116;
  l117:;	  yypos= yypos116; yythunkpos= yythunkpos116;  if (!yy_definition()) goto l113;
  }
  l116:;	  goto l112;
  l113:;	  yypos= yypos113; yythunkpos= yythunkpos113;
  }
  {  int yypos118= yypos, yythunkpos118= yythunkpos;  if (!yy_trailer()) goto l118;  goto l119;
  l118:;	  yypos= yypos118; yythunkpos= yythunkpos118;
  }
  l119:;	  if (!yy_end_of_file()) goto l111;
  yyprintf((stderr, "  ok   %s @ %s\n", "grammar", yybuf+yypos));
  return 1;
  l111:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "grammar", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0xa4fa(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0xa4e9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
callq 0x1da0
cmpl $0x0, %eax
jne 0x1c89
jmp 0x1d7b
movl 0xa4d9(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0xa4c8(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x22a0
cmpl $0x0, %eax
jne 0x1ca7
jmp 0x1ca9
jmp 0x1ccc
movl -0x10(%rbp), %eax
movl %eax, 0xa4b6(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0xa4a5(%rip)      # 0xc160
callq 0x2530
cmpl $0x0, %eax
jne 0x1cca
jmp 0x1d7b
jmp 0x1ccc
jmp 0x1cce
movl 0xa494(%rip), %eax      # 0xc168
movl %eax, -0x18(%rbp)
movl 0xa483(%rip), %eax      # 0xc160
movl %eax, -0x1c(%rbp)
movl 0xa482(%rip), %eax      # 0xc168
movl %eax, -0x20(%rbp)
movl 0xa471(%rip), %eax      # 0xc160
movl %eax, -0x24(%rbp)
callq 0x22a0
cmpl $0x0, %eax
jne 0x1cfe
jmp 0x1d00
jmp 0x1d20
movl -0x20(%rbp), %eax
movl %eax, 0xa45f(%rip)      # 0xc168
movl -0x24(%rbp), %eax
movl %eax, 0xa44e(%rip)      # 0xc160
callq 0x2530
cmpl $0x0, %eax
jne 0x1d1e
jmp 0x1d22
jmp 0x1d20
jmp 0x1cce
movl -0x18(%rbp), %eax
movl %eax, 0xa43d(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0xa42c(%rip)      # 0xc160
movl 0xa42e(%rip), %eax      # 0xc168
movl %eax, -0x28(%rbp)
movl 0xa41d(%rip), %eax      # 0xc160
movl %eax, -0x2c(%rbp)
callq 0x4070
cmpl $0x0, %eax
jne 0x1d52
jmp 0x1d54
jmp 0x1d66
movl -0x28(%rbp), %eax
movl %eax, 0xa40b(%rip)      # 0xc168
movl -0x2c(%rbp), %eax
movl %eax, 0xa3fa(%rip)      # 0xc160
callq 0x4190
cmpl $0x0, %eax
jne 0x1d72
jmp 0x1d7b
movl $0x1, -0x4(%rbp)
jmp 0x1d94
movl -0x8(%rbp), %eax
movl %eax, 0xa3e4(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0xa3d3(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy__
YY_RULE(int) yy__()
{
  yyprintf((stderr, "%s\n", "_"));
  l107:;	
  {  int yypos108= yypos, yythunkpos108= yythunkpos;
  {  int yypos109= yypos, yythunkpos109= yythunkpos;  if (!yy_space()) goto l110;  goto l109;
  l110:;	  yypos= yypos109; yythunkpos= yythunkpos109;  if (!yy_comment()) goto l108;
  }
  l109:;	  goto l107;
  l108:;	  yypos= yypos108; yythunkpos= yythunkpos108;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "_", yybuf+yypos));
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xa3ba(%rip), %eax      # 0xc168
movl %eax, -0x4(%rbp)
movl 0xa3a9(%rip), %eax      # 0xc160
movl %eax, -0x8(%rbp)
movl 0xa3a8(%rip), %eax      # 0xc168
movl %eax, -0xc(%rbp)
movl 0xa397(%rip), %eax      # 0xc160
movl %eax, -0x10(%rbp)
callq 0x1e20
cmpl $0x0, %eax
jne 0x1dd8
jmp 0x1dda
jmp 0x1dfa
movl -0xc(%rbp), %eax
movl %eax, 0xa385(%rip)      # 0xc168
movl -0x10(%rbp), %eax
movl %eax, 0xa374(%rip)      # 0xc160
callq 0x2180
cmpl $0x0, %eax
jne 0x1df8
jmp 0x1dfc
jmp 0x1dfa
jmp 0x1da8
movl -0x4(%rbp), %eax
movl %eax, 0xa363(%rip)      # 0xc168
movl -0x8(%rbp), %eax
movl %eax, 0xa352(%rip)      # 0xc160
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_space
YY_RULE(int) yy_space()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "space"));
  {  int yypos10= yypos, yythunkpos10= yythunkpos;  if (!yymatchChar(' ')) goto l11;  goto l10;
  l11:;	  yypos= yypos10; yythunkpos= yythunkpos10;  if (!yymatchChar('\t')) goto l12;  goto l10;
  l12:;	  yypos= yypos10; yythunkpos= yythunkpos10;  if (!yy_end_of_line()) goto l9;
  }
  l10:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "space", yybuf+yypos));
  return 1;
  l9:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "space", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0xa33a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0xa329(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0xa328(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0xa317(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
movl $0x20, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x1e5d
jmp 0x1e5f
jmp 0x1ea4
movl -0x10(%rbp), %eax
movl %eax, 0xa300(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0xa2ef(%rip)      # 0xc160
movl $0x9, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x1e82
jmp 0x1e84
jmp 0x1ea4
movl -0x10(%rbp), %eax
movl %eax, 0xa2db(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0xa2ca(%rip)      # 0xc160
callq 0x2020
cmpl $0x0, %eax
jne 0x1ea2
jmp 0x1ead
jmp 0x1ea4
movl $0x1, -0x4(%rbp)
jmp 0x1ec6
movl -0x8(%rbp), %eax
movl %eax, 0xa2b2(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0xa2a1(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yymatchChar
YY_LOCAL(int) yymatchChar(int c)
{
  if (yypos >= yylimit && !yyrefill()) return 0;
  if (yybuf[yypos] == c)
    {
      ++yypos;
      yyprintf((stderr, "  ok   yymatchChar(%c) @ %s\n", c, yybuf+yypos));
      return 1;
    }
  yyprintf((stderr, "  fail yymatchChar(%c) @ %s\n", c, yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl 0xa287(%rip), %eax      # 0xc168
cmpl 0xa27d(%rip), %eax      # 0xc164
jl 0x1efc
callq 0x1f40
cmpl $0x0, %eax
jne 0x1efc
movl $0x0, -0x4(%rbp)
jmp 0x1f32
movq 0xa225(%rip), %rax      # 0xc128
movslq 0xa25e(%rip), %rcx      # 0xc168
movsbl (%rax,%rcx), %eax
cmpl -0x8(%rbp), %eax
jne 0x1f2b
movl 0xa24f(%rip), %eax      # 0xc168
addl $0x1, %eax
movl %eax, 0xa246(%rip)      # 0xc168
movl $0x1, -0x4(%rbp)
jmp 0x1f32
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyrefill
YY_LOCAL(int) yyrefill(void)
{
  int yyn;
  while (yybuflen - yypos < 512)
    {
      yybuflen *= 2;
      yybuf= realloc(yybuf, yybuflen);
    }
  YY_INPUT((yybuf + yypos), yyn, (yybuflen - yypos));
  if (!yyn) return 0;
  yylimit += yyn;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xa1d6(%rip), %eax      # 0xc124
subl 0xa214(%rip), %eax      # 0xc168
cmpl $0x200, %eax            # imm = 0x200
jge 0x1f85
movl 0xa1c3(%rip), %eax      # 0xc124
shll %eax
movl %eax, 0xa1bb(%rip)      # 0xc124
movq 0xa1b8(%rip), %rdi      # 0xc128
movslq 0xa1ad(%rip), %rsi      # 0xc124
callq 0x1110
movq %rax, 0xa1a5(%rip)      # 0xc128
jmp 0x1f48
movq 0xa18c(%rip), %rdi      # 0xc118
callq 0x1190
movl %eax, -0xc(%rbp)
movl $0xa, %eax
cmpl -0xc(%rbp), %eax
je 0x1fa8
movl $0xd, %eax
cmpl -0xc(%rbp), %eax
jne 0x1fb7
movl 0xa1da(%rip), %eax      # 0xc188
addl $0x1, %eax
movl %eax, 0xa1d1(%rip)      # 0xc188
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x1fc8
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fe6
movl -0xc(%rbp), %eax
movb %al, %dl
movq 0xa154(%rip), %rax      # 0xc128
movslq 0xa18d(%rip), %rcx      # 0xc168
movb %dl, (%rax,%rcx)
movl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1ffb
movl $0x0, -0x4(%rbp)
jmp 0x2011
movl -0x8(%rbp), %eax
addl 0xa160(%rip), %eax      # 0xc164
movl %eax, 0xa15a(%rip)      # 0xc164
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_end_of_line
YY_RULE(int) yy_end_of_line()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "end_of_line"));
  {  int yypos2= yypos, yythunkpos2= yythunkpos;  if (!yymatchString("\r\n")) goto l3;  goto l2;
  l3:;	  yypos= yypos2; yythunkpos= yythunkpos2;  if (!yymatchChar('\n')) goto l4;  goto l2;
  l4:;	  yypos= yypos2; yythunkpos= yythunkpos2;  if (!yymatchChar('\r')) goto l1;
  }
  l2:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "end_of_line", yybuf+yypos));
  return 1;
  l1:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "end_of_line", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0xa13a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0xa129(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0xa128(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0xa117(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
leaq 0x517b(%rip), %rdi      # 0x71ce
callq 0x20e0
cmpl $0x0, %eax
jne 0x205f
jmp 0x2061
jmp 0x20ab
movl -0x10(%rbp), %eax
movl %eax, 0xa0fe(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0xa0ed(%rip)      # 0xc160
movl $0xa, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2084
jmp 0x2086
jmp 0x20ab
movl -0x10(%rbp), %eax
movl %eax, 0xa0d9(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0xa0c8(%rip)      # 0xc160
movl $0xd, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x20a9
jmp 0x20b4
jmp 0x20ab
movl $0x1, -0x4(%rbp)
jmp 0x20cd
movl -0x8(%rbp), %eax
movl %eax, 0xa0ab(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0xa09a(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yymatchString
YY_LOCAL(int) yymatchString(char *s)
{
  int yysav= yypos;
  while (*s)
    {
      if (yypos >= yylimit && !yyrefill()) return 0;
      if (yybuf[yypos] != *s)
        {
          yypos= yysav;
          return 0;
        }
      ++s;
      ++yypos;
    }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0xa076(%rip), %eax      # 0xc168
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x216b
movl 0xa064(%rip), %eax      # 0xc168
cmpl 0xa05a(%rip), %eax      # 0xc164
jl 0x211f
callq 0x1f40
cmpl $0x0, %eax
jne 0x211f
movl $0x0, -0x4(%rbp)
jmp 0x2172
movq 0xa002(%rip), %rax      # 0xc128
movslq 0xa03b(%rip), %rcx      # 0xc168
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x214e
movl -0x14(%rbp), %eax
movl %eax, 0xa023(%rip)      # 0xc168
movl $0x0, -0x4(%rbp)
jmp 0x2172
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl 0xa008(%rip), %eax      # 0xc168
addl $0x1, %eax
movl %eax, 0x9fff(%rip)      # 0xc168
jmp 0x20f5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_comment
YY_RULE(int) yy_comment()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "comment"));  if (!yymatchChar('#')) goto l5;
  l6:;	
  {  int yypos7= yypos, yythunkpos7= yythunkpos;
  {  int yypos8= yypos, yythunkpos8= yythunkpos;  if (!yy_end_of_line()) goto l8;  goto l7;
  l8:;	  yypos= yypos8; yythunkpos= yythunkpos8;
  }  if (!yymatchDot()) goto l7;  goto l6;
  l7:;	  yypos= yypos7; yythunkpos= yythunkpos7;
  }  if (!yy_end_of_line()) goto l5;
  yyprintf((stderr, "  ok   %s @ %s\n", "comment", yybuf+yypos));
  return 1;
  l5:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "comment", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x9fda(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9fc9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x23, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x21ab
jmp 0x2226
jmp 0x21ad
movl 0x9fb5(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9fa4(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
movl 0x9fa3(%rip), %eax      # 0xc168
movl %eax, -0x18(%rbp)
movl 0x9f92(%rip), %eax      # 0xc160
movl %eax, -0x1c(%rbp)
callq 0x2020
cmpl $0x0, %eax
jne 0x21dd
jmp 0x21df
jmp 0x21ff
movl -0x18(%rbp), %eax
movl %eax, 0x9f80(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0x9f6f(%rip)      # 0xc160
callq 0x2250
cmpl $0x0, %eax
jne 0x21fd
jmp 0x21ff
jmp 0x21ad
movl -0x10(%rbp), %eax
movl %eax, 0x9f60(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9f4f(%rip)      # 0xc160
callq 0x2020
cmpl $0x0, %eax
jne 0x221d
jmp 0x2226
movl $0x1, -0x4(%rbp)
jmp 0x223f
movl -0x8(%rbp), %eax
movl %eax, 0x9f39(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9f28(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_declaration
YY_RULE(int) yy_declaration()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "declaration"));  if (!yymatchString("%{")) goto l102;  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l102;
  l103:;	
  {  int yypos104= yypos, yythunkpos104= yythunkpos;
  {  int yypos105= yypos, yythunkpos105= yythunkpos;  if (!yymatchString("%}")) goto l105;  goto l104;
  l105:;	  yypos= yypos105; yythunkpos= yythunkpos105;
  }  if (!yymatchDot()) goto l104;  goto l103;
  l104:;	  yypos= yypos104; yythunkpos= yythunkpos104;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l102;  if (!yy_RPERCENT()) goto l102;  yyDo(yy_1_declaration, yybegin, yyend);
  yyprintf((stderr, "  ok   %s @ %s\n", "declaration", yybuf+yypos));
  return 1;
  l102:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "declaration", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x9eba(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9ea9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
leaq 0x4f10(%rip), %rdi      # 0x71d1
callq 0x20e0
cmpl $0x0, %eax
jne 0x22d0
jmp 0x23b7
movl 0x9e9a(%rip), %edi      # 0xc170
movl 0x9e90(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x9e81(%rip), %eax      # 0xc168
movl %eax, 0x9e83(%rip)      # 0xc170
movb $0x1, %al
testb $0x1, %al
jne 0x22f8
jmp 0x23b7
jmp 0x22fa
movl 0x9e68(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9e57(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
movl 0x9e56(%rip), %eax      # 0xc168
movl %eax, -0x18(%rbp)
movl 0x9e45(%rip), %eax      # 0xc160
movl %eax, -0x1c(%rbp)
leaq 0x4eaf(%rip), %rdi      # 0x71d4
callq 0x20e0
cmpl $0x0, %eax
jne 0x2331
jmp 0x2333
jmp 0x2353
movl -0x18(%rbp), %eax
movl %eax, 0x9e2c(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0x9e1b(%rip)      # 0xc160
callq 0x2250
cmpl $0x0, %eax
jne 0x2351
jmp 0x2353
jmp 0x22fa
movl -0x10(%rbp), %eax
movl %eax, 0x9e0c(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9dfb(%rip)      # 0xc160
movl 0x9e05(%rip), %edi      # 0xc170
movl 0x9dfb(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x9dec(%rip), %eax      # 0xc168
movl %eax, 0x9dea(%rip)      # 0xc16c
movb $0x1, %al
testb $0x1, %al
jne 0x238a
jmp 0x23b7
callq 0x24c0
cmpl $0x0, %eax
jne 0x2396
jmp 0x23b7
movl 0x9dd4(%rip), %esi      # 0xc170
movl 0x9dca(%rip), %edx      # 0xc16c
leaq 0xf7(%rip), %rdi        # 0x24a0
callq 0x23e0
movl $0x1, -0x4(%rbp)
jmp 0x23d0
movl -0x8(%rbp), %eax
movl %eax, 0x9da8(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9d97(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yyDo
YY_LOCAL(void) yyDo(yyaction action, int begin, int end)
{
  while (yythunkpos >= yythunkslen)
    {
      yythunkslen *= 2;
      yythunks= realloc(yythunks, sizeof(yythunk) * yythunkslen);
    }
  yythunks[yythunkpos].begin=  begin;
  yythunks[yythunkpos].end=    end;
  yythunks[yythunkpos].action= action;
  ++yythunkpos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl 0x9d68(%rip), %eax      # 0xc160
cmpl 0x9d42(%rip), %eax      # 0xc140
jl 0x242e
movl 0x9d3a(%rip), %eax      # 0xc140
shll %eax
movl %eax, 0x9d32(%rip)      # 0xc140
movq 0x9d33(%rip), %rdi      # 0xc148
movslq 0x9d24(%rip), %rax      # 0xc140
imulq $0x18, %rax, %rsi
callq 0x1110
movq %rax, 0x9d1c(%rip)      # 0xc148
jmp 0x23f2
movl -0xc(%rbp), %ecx
movq 0x9d10(%rip), %rax      # 0xc148
movslq 0x9d21(%rip), %rdx      # 0xc160
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq 0x9cf6(%rip), %rax      # 0xc148
movslq 0x9d07(%rip), %rdx      # 0xc160
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq 0x9cda(%rip), %rax      # 0xc148
movslq 0x9ceb(%rip), %rdx      # 0xc160
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x9cda(%rip), %eax      # 0xc160
addl $0x1, %eax
movl %eax, 0x9cd1(%rip)      # 0xc160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_RPERCENT
YY_RULE(int) yy_RPERCENT()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "RPERCENT"));  if (!yymatchString("%}")) goto l93;  if (!yy__()) goto l93;
  yyprintf((stderr, "  ok   %s @ %s\n", "RPERCENT", yybuf+yypos));
  return 1;
  l93:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "RPERCENT", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x9c9a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9c89(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
leaq 0x4cf3(%rip), %rdi      # 0x71d4
callq 0x20e0
cmpl $0x0, %eax
jne 0x24ed
jmp 0x2502
callq 0x1da0
cmpl $0x0, %eax
jne 0x24f9
jmp 0x2502
movl $0x1, -0x4(%rbp)
jmp 0x251b
movl -0x8(%rbp), %eax
movl %eax, 0x9c5d(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9c4c(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_definition
YY_RULE(int) yy_definition()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "definition"));  if (!yy_identifier()) goto l99;  yyDo(yy_1_definition, yybegin, yyend);  if (!yy_EQUAL()) goto l99;  if (!yy_expression()) goto l99;  yyDo(yy_2_definition, yybegin, yyend);
  {  int yypos100= yypos, yythunkpos100= yythunkpos;  if (!yy_SEMICOLON()) goto l100;  goto l101;
  l100:;	  yypos= yypos100; yythunkpos= yythunkpos100;
  }
  l101:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "definition", yybuf+yypos));
  return 1;
  l99:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "definition", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x9c2a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9c19(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
callq 0x2690
cmpl $0x0, %eax
jne 0x2559
jmp 0x25dc
movl 0x9c11(%rip), %esi      # 0xc170
movl 0x9c07(%rip), %edx      # 0xc16c
leaq 0x94(%rip), %rdi        # 0x2600
callq 0x23e0
callq 0x2820
cmpl $0x0, %eax
jne 0x257d
jmp 0x25dc
callq 0x2890
cmpl $0x0, %eax
jne 0x2589
jmp 0x25dc
movl 0x9be1(%rip), %esi      # 0xc170
movl 0x9bd7(%rip), %edx      # 0xc16c
leaq 0xc4(%rip), %rdi        # 0x2660
callq 0x23e0
movl 0x9bc1(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9bb0(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x4000
cmpl $0x0, %eax
jne 0x25bf
jmp 0x25c1
jmp 0x25d3
movl -0x10(%rbp), %eax
movl %eax, 0x9b9e(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9b8d(%rip)      # 0xc160
movl $0x1, -0x4(%rbp)
jmp 0x25f5
movl -0x8(%rbp), %eax
movl %eax, 0x9b83(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9b72(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_identifier
YY_RULE(int) yy_identifier()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "identifier"));  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l90;  if (!yymatchClass((unsigned char *)"\000\000\000\000\000\040\000\000\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l90;
  l91:;	
  {  int yypos92= yypos, yythunkpos92= yythunkpos;  if (!yymatchClass((unsigned char *)"\000\000\000\000\000\040\377\003\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l92;  goto l91;
  l92:;	  yypos= yypos92; yythunkpos= yythunkpos92;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l90;  if (!yy__()) goto l90;
  yyprintf((stderr, "  ok   %s @ %s\n", "identifier", yybuf+yypos));
  return 1;
  l90:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "identifier", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x9aca(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9ab9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0x9ac0(%rip), %edi      # 0xc170
movl 0x9ab6(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x9aa7(%rip), %eax      # 0xc168
movl %eax, 0x9aa9(%rip)      # 0xc170
movb $0x1, %al
testb $0x1, %al
jne 0x26d2
jmp 0x275a
leaq 0x49af(%rip), %rdi      # 0x7088
callq 0x2780
cmpl $0x0, %eax
jne 0x26e5
jmp 0x275a
jmp 0x26e7
movl 0x9a7b(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9a6a(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
leaq 0x49a9(%rip), %rdi      # 0x70a9
callq 0x2780
cmpl $0x0, %eax
jne 0x270c
jmp 0x270e
jmp 0x26e7
movl -0x10(%rbp), %eax
movl %eax, 0x9a51(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9a40(%rip)      # 0xc160
movl 0x9a4a(%rip), %edi      # 0xc170
movl 0x9a40(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x9a31(%rip), %eax      # 0xc168
movl %eax, 0x9a2f(%rip)      # 0xc16c
movb $0x1, %al
testb $0x1, %al
jne 0x2745
jmp 0x275a
callq 0x1da0
cmpl $0x0, %eax
jne 0x2751
jmp 0x275a
movl $0x1, -0x4(%rbp)
jmp 0x2773
movl -0x8(%rbp), %eax
movl %eax, 0x9a05(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x99f4(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yymatchClass
YY_LOCAL(int) yymatchClass(unsigned char *bits)
{
  int c;
  if (yypos >= yylimit && !yyrefill()) return 0;
  c= yybuf[yypos];
  if (bits[c >> 3] & (1 << (c & 7)))
    {
      ++yypos;
      yyprintf((stderr, "  ok   yymatchClass @ %s\n", yybuf+yypos));
      return 1;
    }
  yyprintf((stderr, "  fail yymatchClass @ %s\n", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x99d6(%rip), %eax      # 0xc168
cmpl 0x99cc(%rip), %eax      # 0xc164
jl 0x27ad
callq 0x1f40
cmpl $0x0, %eax
jne 0x27ad
movl $0x0, -0x4(%rbp)
jmp 0x2808
movq 0x9974(%rip), %rax      # 0xc128
movslq 0x99ad(%rip), %rcx      # 0xc168
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2801
movl 0x9979(%rip), %eax      # 0xc168
addl $0x1, %eax
movl %eax, 0x9970(%rip)      # 0xc168
movl $0x1, -0x4(%rbp)
jmp 0x2808
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)