LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: getposition
static int getposition (lua_State *L, int t, int i) {
  int res;
  lua_getfenv(L, -1);
  lua_rawgeti(L, -1, i);  /* get key from pattern's environment */
  lua_gettable(L, t);  /* get position from positions table */
  res = lua_tointeger(L, -1);
  if (res == 0) {  /* key has no registered position? */
    lua_rawgeti(L, -2, i);  /* get key again */
    return luaL_error(L, "%s is not defined in given grammar", val2str(L, -1));
  }
  lua_pop(L, 2);  /* remove environment and position */
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
pushq $-0x1
popq %r15
movl %r15d, %esi
callq 0x1dc8e2
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1dc73a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1dc524
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1dbb20
movq %rax, %r14
testl %r14d, %r14d
je 0x1f1f14
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x1db3d2
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x2
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1dc73a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x1f1dc6
leaq 0x177e7b(%rip), %rsi    # 0x369dae
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1de79c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: optimizejumps
static void optimizejumps (Instruction *p) {
  int i;
  for (i = 0; p[i].i.code != IEnd; i += sizei(p + i)) {
    if (isjmp(p + i))
      p[i].i.offset = target(p, dest(p, i)) - i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0xfdc478, %r15d        # imm = 0xFDC478
movl %ebp, %eax
movzbl (%rbx,%rax,8), %ecx
cmpq $0x6, %rcx
je 0x1f1fcd
leaq (%rbx,%rax,8), %r14
btq %rcx, %r15
jb 0x1f1fc1
movswl 0x2(%r14), %esi
testl %esi, %esi
je 0x1f1fc1
addl %ebp, %esi
movq %rbx, %rdi
callq 0x1f1f4a
subl %ebp, %eax
movw %ax, 0x2(%r14)
movq %r14, %rdi
callq 0x1f1f5f
addl %eax, %ebp
jmp 0x1f1f91
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: jointable
static int jointable (lua_State *L, int p1) {
  int n, n1, i;
  lua_getfenv(L, p1);
  n1 = ktablelen(L, -1);  /* number of elements in p1's env */
  lua_getfenv(L, -2);
  if (n1 == 0 || lua_equal(L, -2, -1)) {
    lua_pop(L, 2);
    return 0;  /* no need to change anything */
  }
  n = ktablelen(L, -1);  /* number of elements in p's env */
  if (n == 0) {
    lua_pop(L, 1);  /* removes p env */
    lua_setfenv(L, -2);  /* p now shares p1's env */
    return 0;  /* no need to correct anything */
  }
  lua_createtable(L, n + n1, 0);
  /* stack: p; p1 env; p env; new p env */
  for (i = 1; i <= n; i++) {
    lua_rawgeti(L, -2, i);
    lua_rawseti(L, -2, i);
  }
  for (i = 1; i <= n1; i++) {
    lua_rawgeti(L, -3, i);
    lua_rawseti(L, -2, n + i);
  }
  lua_setfenv(L, -4);  /* new table becomes p env */
  lua_pop(L, 2);  /* remove p1 env and old p env */
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1dc8e2
movq %rbx, %rdi
callq 0x1f210e
movl %eax, %r15d
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x1dc8e2
testl %r15d, %r15d
je 0x1f2018
pushq $-0x2
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x1db8c6
testl %eax, %eax
je 0x1f2038
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x1db3d2
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1f210e
testl %eax, %eax
je 0x1f20f2
movl %eax, %r14d
leal (%r14,%r15), %esi
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1dc7bd
testl %r14d, %r14d
cmovgl %r14d, %r13d
negl %r13d
pushq $0x1
popq %r12
pushq $-0x2
popq %rbp
leal (%r12,%r13), %eax
cmpl $0x1, %eax
je 0x1f2095
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x1dc73a
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x1dcc5f
incl %r12d
jmp 0x1f206d
xorl %r13d, %r13d
testl %r15d, %r15d
cmovgl %r15d, %r13d
negl %r13d
pushq $0x1
popq %r15
pushq $-0x3
popq %rbp
pushq $-0x2
popq %r12
leal (%r15,%r13), %eax
cmpl $0x1, %eax
je 0x1f20d7
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1dc73a
leal (%r14,%r15), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1dcc5f
incl %r15d
jmp 0x1f20ad
pushq $-0x4
popq %rsi
movq %rbx, %rdi
callq 0x1dcdc1
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x1db3d2
jmp 0x1f2026
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1db3d2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1dcdc1
jmp 0x1f2023
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: auxnew
static Instruction *auxnew (lua_State *L, Instruction **op, int *size,
                                         int extra) {
  *op = newpatt(L, *size + extra);
  jointable(L, 1);
  *size += extra;
  return *op + *size - extra;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rdx), %rsi
movslq %ecx, %r12
addq %r12, %rsi
callq 0x1f0978
movq %rax, (%r14)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x1f1fd8
movslq (%rbx), %rax
addq %r12, %rax
movl %eax, (%rbx)
shlq $0x3, %rax
addq (%r14), %rax
shlq $0x3, %r12
subq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: isheadfail
static int isheadfail (Instruction *p) {
  if (!ischeck(p)) return 0;
  /* check that other operations cannot fail */
  for (p += sizei(p); p->i.code != IEnd; p += sizei(p))
    if (!isnofail(p)) return 0;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
xorl %ebx, %ebx
movl $0xfdfff8, %ecx         # imm = 0xFDFFF8
btq %rax, %rcx
jb 0x1f25ea
movq %rdi, %r14
cmpw $0x0, 0x2(%rdi)
jne 0x1f25ea
pushq $0x1
popq %rbp
movl $0x83fef7, %r15d        # imm = 0x83FEF7
movq %r14, %rdi
callq 0x1f1f5f
movl %eax, %eax
movzbl (%r14,%rax,8), %ecx
cmpq $0x6, %rcx
je 0x1f25e8
leaq (%r14,%rax,8), %r14
btq %rcx, %r15
jae 0x1f25c7
jmp 0x1f25ea
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: optimizechoice
static void optimizechoice (Instruction *p) {
  assert(p->i.code == IChoice);
  if (isfixcheck(p + 1)) {
    int lc = sizei(p + 1);
    rotate(p, lc, 1);
    assert(isfixcheck(p) && (p + lc)->i.code == IChoice);
    (p + lc)->i.aux = op_step(p);
    check2test(p, (p + lc)->i.offset);
    (p + lc)->i.offset -= lc;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x7, (%rdi)
jne 0x1f26b2
movq %rdi, %rbx
movzbl 0x8(%rdi), %eax
addq $-0x3, %rax
cmpq $0x15, %rax
jb 0x1f26ad
cmpw $0x0, 0xa(%rbx)
jne 0x1f26ad
leaq 0x8(%rbx), %rdi
callq 0x1f1f5f
movl %eax, %ebp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x1f2711
movzbl (%rbx), %eax
leaq -0x3(%rax), %rcx
cmpq $0x15, %rcx
jb 0x1f26d1
cmpw $0x0, 0x2(%rbx)
jne 0x1f26d1
movl %ebp, %r14d
cmpb $0x7, (%rbx,%r14,8)
jne 0x1f26d1
movb $0x1, %cl
testb %al, %al
jne 0x1f2694
movb 0x1(%rbx), %cl
movb %cl, 0x1(%rbx,%r14,8)
movswl 0x2(%rbx,%r14,8), %esi
movq %rbx, %rdi
callq 0x1f25f7
subw %bp, 0x2(%rbx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x177751(%rip), %rdi    # 0x369e0a
leaq 0x177422(%rip), %rsi    # 0x369ae2
leaq 0x177758(%rip), %rcx    # 0x369e1f
movl $0x398, %edx            # imm = 0x398
callq 0x174b0
leaq 0x17776a(%rip), %rdi    # 0x369e42
leaq 0x177403(%rip), %rsi    # 0x369ae2
leaq 0x177739(%rip), %rcx    # 0x369e1f
movl $0x39c, %edx            # imm = 0x39C
callq 0x174b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: invert
static void invert (Instruction *p, int e) {
  int i;
  for (i = 0; i < e; i++, e--) {
    Instruction temp = p[i];
    p[i] = p[e];
    p[e] = temp;
  }
}

// Assembly:
movslq %esi, %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x1f2761
movq (%rdi,%rcx,8), %rdx
movq (%rdi,%rax,8), %rsi
movq %rsi, (%rdi,%rcx,8)
movq %rdx, (%rdi,%rax,8)
incq %rcx
decq %rax
jmp 0x1f2744
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: skipchecks
static int skipchecks (Instruction *p, int up, int *pn) {
  int i, n = 0;
  for (i = 0; isfixcheck(p + i); i += sizei(p + i)) {
    int st = op_step(p + i);
    if (n + st > MAXOFF - up) break;
    n += st;
  }
  *pn = n;
  return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
pushq $0xf
popq %r15
subl %esi, %r15d
xorl %eax, %eax
pushq $0x1
popq %r12
xorl %ebp, %ebp
movl %ebp, %edx
movzbl (%r14,%rdx,8), %ecx
leaq -0x3(%rcx), %rsi
cmpq $0x15, %rsi
jb 0x1f2984
leaq (%r14,%rdx,8), %rdi
cmpw $0x0, 0x2(%rdi)
jne 0x1f2984
movl %r12d, %r13d
testb %cl, %cl
jne 0x1f2970
movzbl 0x1(%rdi), %r13d
addl %eax, %r13d
cmpl %r15d, %r13d
ja 0x1f2984
callq 0x1f1f5f
addl %eax, %ebp
movl %r13d, %eax
jmp 0x1f2948
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: newcharset
static Instruction *newcharset (lua_State *L) {
  Instruction *p = newpatt(L, CHARSETINSTSIZE);
  p[0].i.code = ISet;
  p[0].i.offset = 0;
  loopset(i, p[1].buff[i] = 0);
  return p;
}

// Assembly:
pushq %rax
pushq $0x5
popq %rsi
callq 0x1f0978
movb $0x2, (%rax)
andw $0x0, 0x2(%rax)
pushq $0x8
popq %rcx
cmpq $0x28, %rcx
je 0x1f29ba
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x1f29ab
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: capture_aux
static int capture_aux (lua_State *L, int kind, int labelidx) {
  int l1, n;
  Instruction *p1 = getpatt(L, 1, &l1);
  int lc = skipchecks(p1, 0, &n);
  if (lc == l1) {  /* got whole pattern? */
    /* may use a IFullCapture instruction at its end */
    Instruction *p = newpatt(L, l1 + 1);
    int label = getlabel(L, labelidx);
    p += addpatt(L, p, 1);
    setinstcap(p, IFullCapture, label, kind, n);
  }
  else {  /* must use open-close pair */
    Instruction *op = newpatt(L, 1 + l1 + 1);
    Instruction *p = op;
    setinstcap(p++, IOpenCapture, getlabel(L, labelidx), kind, 0);
    p += addpatt(L, p, 1);
    setinstcap(p, ICloseCapture, 0, Cclose, 0);
    optimizecaptures(op);
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rsi
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x1f10c5
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1f2928
movslq (%r15), %rsi
cmpl %esi, %eax
jne 0x1f2a3a
incl %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0x1f0978
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f2a94
movl %eax, %ebp
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f1e11
cltq
leaq (%r15,%rax,8), %rdi
movl 0x8(%rsp), %ecx
shll $0x4, %ecx
orl %ebx, %ecx
pushq $0x12
popq %rsi
movl %ebp, %edx
callq 0x1f09e0
jmp 0x1f2a87
addq $0x2, %rsi
movq %r14, %rdi
callq 0x1f0978
movq %rax, %r15
leaq 0x8(%rax), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f2a94
pushq $0x15
popq %rsi
movq %r15, %rdi
movl %eax, %edx
movl %ebx, %ecx
callq 0x1f09e0
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1f1e11
cltq
movl $0x16, 0x8(%r15,%rax,8)
movq %r15, %rdi
callq 0x1f2762
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: printpat_l
static int printpat_l (lua_State *L) {
  Instruction *p = getpatt(L, 1, NULL);
  int n, i;
  lua_getfenv(L, 1);
  n = ktablelen(L, -1);
  printf("[");
  for (i = 1; i <= n; i++) {
    printf("%d = ", i);
    lua_rawgeti(L, -1, i);
    if (lua_isstring(L, -1))
      printf("%s  ", lua_tostring(L, -1));
    else
      printf("%s  ", lua_typename(L, lua_type(L, -1)));
    lua_pop(L, 1);
  }
  printf("]\n");
  printpatt(p);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
pushq $0x1
popq %r14
movl %r14d, %esi
xorl %edx, %edx
callq 0x1f10c5
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1dc8e2
movq %rbx, %rdi
callq 0x1f210e
movl %eax, %r12d
pushq $0x5b
popq %rdi
callq 0x179c0
testl %r12d, %r12d
cmovlel %r13d, %r12d
negl %r12d
pushq $-0x1
popq %rbp
pushq $-0x2
popq %r13
leal (%r12,%r14), %eax
cmpl $0x1, %eax
je 0x1f3568
leaq 0x176de4(%rip), %rdi    # 0x36a2e9
movl %r14d, %esi
xorl %eax, %eax
callq 0x17070
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x1dc73a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1db803
movq %rbx, %rdi
movl %ebp, %esi
testl %eax, %eax
je 0x1f3538
xorl %edx, %edx
callq 0x1dbb73
jmp 0x1f3547
callq 0x1db731
movq %rbx, %rdi
movl %eax, %esi
callq 0x1db74a
leaq 0x176da1(%rip), %rdi    # 0x36a2ef
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movq %rbx, %rdi
movl %r13d, %esi
callq 0x1db3d2
incl %r14d
jmp 0x1f34f5
leaq 0x174c73(%rip), %rdi    # 0x3681e2
callq 0x17b60
leaq 0x176475(%rip), %r12    # 0x3699f0
leaq 0x176dfb(%rip), %r14    # 0x36a37d
pushq $0xa
popq %rbp
leaq 0x1763c4(%rip), %r13    # 0x369950
movq %r15, %rbx
movq %rbx, %rsi
subq %r15, %rsi
sarq $0x3, %rsi
movzbl (%rbx), %eax
movslq (%r12,%rax,4), %rdx
addq %r12, %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
movzbl (%rbx), %eax
cmpq $0x17, %rax
ja 0x1f365a
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movzbl 0x1(%rbx), %eax
andl $0xf, %eax
leaq 0x17647e(%rip), %rcx    # 0x369a50
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x1758c9(%rip), %rdi    # 0x368ea9
xorl %eax, %eax
callq 0x17070
movzbl 0x1(%rbx), %esi
shrl $0x4, %esi
movswl 0x2(%rbx), %edx
leaq 0x176d94(%rip), %rdi    # 0x36a38d
xorl %eax, %eax
callq 0x17070
jmp 0x1f365a
movzbl 0x1(%rbx), %esi
leaq 0x117069(%rip), %rdi    # 0x30a676
jmp 0x1f3648
leaq 0x8(%rbx), %rdi
callq 0x1f48c9
jmp 0x1f364f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1f4872
movzbl 0x1(%rbx), %esi
leaq 0x123ff1(%rip), %rdi    # 0x317621
jmp 0x1f3684
leaq 0x8(%rbx), %rdi
callq 0x1f48c9
jmp 0x1f365a
movzbl 0x1(%rbx), %esi
leaq 0x176d40(%rip), %rdi    # 0x36a388
xorl %eax, %eax
callq 0x17070
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1f4872
movl %ebp, %edi
callq 0x179c0
cmpb $0x6, (%rbx)
je 0x1f368d
movq %rbx, %rdi
callq 0x1f1f5f
movl %eax, %eax
leaq (%rbx,%rax,8), %rbx
jmp 0x1f358f
movswl 0x2(%rbx), %esi
leaq 0x176d1e(%rip), %rdi    # 0x36a3a2
xorl %eax, %eax
callq 0x17070
jmp 0x1f365a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: locale_l
static int locale_l (lua_State *L) {
  if (lua_isnoneornil(L, 1)) {
    lua_settop(L, 0);
    lua_createtable(L, 0, 12);
  }
  else {
    luaL_checktype(L, 1, LUA_TTABLE);
    lua_settop(L, 1);
  }
  createcat(L, "alnum", isalnum);
  createcat(L, "alpha", isalpha);
  createcat(L, "cntrl", iscntrl);
  createcat(L, "digit", isdigit);
  createcat(L, "graph", isgraph);
  createcat(L, "lower", islower);
  createcat(L, "print", isprint);
  createcat(L, "punct", ispunct);
  createcat(L, "space", isspace);
  createcat(L, "upper", isupper);
  createcat(L, "xdigit", isxdigit);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1db731
testl %eax, %eax
jle 0x1f36cc
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1deaea
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1db3d2
jmp 0x1f36e3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1db3d2
pushq $0xc
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1dc7bd
leaq 0x176cf0(%rip), %rsi    # 0x36a3da
movq 0x24482f(%rip), %rdx    # 0x437f20
movq %rbx, %rdi
callq 0x1f495d
leaq 0x18c124(%rip), %rsi    # 0x37f824
movq 0x244891(%rip), %rdx    # 0x437f98
movq %rbx, %rdi
callq 0x1f495d
leaq 0x176cca(%rip), %rsi    # 0x36a3e0
movq 0x244863(%rip), %rdx    # 0x437f80
movq %rbx, %rdi
callq 0x1f495d
leaq 0x176cc1(%rip), %rsi    # 0x36a3ed
movq 0x2447d5(%rip), %rdx    # 0x437f08
movq %rbx, %rdi
callq 0x1f495d
leaq 0x15ca6b(%rip), %rsi    # 0x3501ad
movq 0x2447c7(%rip), %rdx    # 0x437f10
movq %rbx, %rdi
callq 0x1f495d
leaq 0x1758f8(%rip), %rsi    # 0x369050
movq 0x2447f9(%rip), %rdx    # 0x437f58
movq %rbx, %rdi
callq 0x1f495d
leaq 0x10a7d2(%rip), %rsi    # 0x2fdf40
movq 0x24485b(%rip), %rdx    # 0x437fd0
movq %rbx, %rdi
callq 0x1f495d
leaq 0x176c62(%rip), %rsi    # 0x36a3e6
movq 0x244865(%rip), %rdx    # 0x437ff0
movq %rbx, %rdi
callq 0x1f495d
leaq 0x13998e(%rip), %rsi    # 0x32d128
movq 0x244707(%rip), %rdx    # 0x437ea8
movq %rbx, %rdi
callq 0x1f495d
leaq 0x1925cc(%rip), %rsi    # 0x385d7c
movq 0x244739(%rip), %rdx    # 0x437ef0
movq %rbx, %rdi
callq 0x1f495d
leaq 0x176c26(%rip), %rsi    # 0x36a3ec
movq 0x2446fb(%rip), %rdx    # 0x437ec8
movq %rbx, %rdi
callq 0x1f495d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: setmax
static int setmax (lua_State *L) {
  luaL_optinteger(L, 1, -1);
  lua_settop(L, 1);
  lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $-0x1
popq %rdx
movl %ebp, %esi
callq 0x1dec14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1db3d2
leaq 0x17629d(%rip), %rdx    # 0x369aa0
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x1dcb19
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: pattbehind
static int pattbehind (lua_State *L) {
  int l1;
  CharsetTag st1;
  Instruction *p1 = getpatt(L, 1, &l1);
  int n = luaL_optint(L, 2, 1);
  luaL_argcheck(L, n <= MAXAUX, 2, "lookbehind delta too large");
  if (!nocalls(p1))
    luaL_error(L, "lookbehind pattern cannot contain non terminals");
  if (isfail(p1) || issucc(p1))
    lua_pushvalue(L, 1);  /* <fail == fail; <true == true */
  else if (n == 1 && tocharset(p1, &st1) == ISCHARSET) {
    Instruction *p = newpatt(L, 1 + l1);
    setinstaux(p, IBack, 0, 1); p++;
    copypatt(p, p1, l1);
  }
  else {  /* Choice L1; Back; p1; BackCommit L2; L1: fail; L2: */
    Instruction *p = newpatt(L, 2 + l1 + 2);
    setinst(p++, IChoice, 2 + l1 + 1);
    setinstaux(p++, IBack, 0, n);
    p += addpatt(L, p, 1);
    setinst(p++, IBackCommit, 2);
    setinst(p, IFail, 0);
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x1f10c5
movq %rax, %r14
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1dec14
movq %rax, %r15
cmpl $0x100, %r15d           # imm = 0x100
jl 0x1f3861
leaq 0x176b9d(%rip), %rdx    # 0x36a3f3
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1de6f4
movq %r14, %r12
movzbl (%r12), %eax
cmpl $0x6, %eax
je 0x1f3894
cmpl $0xa, %eax
je 0x1f3883
movq %r12, %rdi
callq 0x1f1f5f
movl %eax, %eax
leaq (%r12,%rax,8), %r12
jmp 0x1f3864
leaq 0x176b84(%rip), %rsi    # 0x36a40e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1de79c
movzbl (%r14), %eax
cmpl $0xf, %eax
je 0x1f38a2
cmpl $0x6, %eax
jne 0x1f38b2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1db711
jmp 0x1f3950
cmpl $0x1, %r15d
jne 0x1f38f5
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x1f1790
cmpl $0x1, %eax
jne 0x1f38f5
movslq (%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x1f0978
movl $0x104, (%rax)          # imm = 0x104
leaq 0x8(%rax), %rdi
movslq (%rsp), %rdx
shlq $0x3, %rdx
movq %r14, %rsi
callq 0x17630
jmp 0x1f3950
movslq (%rsp), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x1f0978
movq %rax, %r14
leaq 0x8(%rax), %rdi
movl (%rsp), %eax
movw $0x7, (%r14)
addl $0x3, %eax
movw %ax, 0x2(%r14)
leaq 0x10(%r14), %r12
pushq $0x4
popq %rsi
xorl %edx, %edx
movl %r15d, %ecx
callq 0x1f09e0
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f1e11
cltq
movl $0x2000d, 0x10(%r14,%rax,8) # imm = 0x2000D
movl $0xf, 0x18(%r14,%rax,8)
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: capconst_l
static int capconst_l (lua_State *L) {
  int i, j;
  int n = lua_gettop(L);
  Instruction *p = newpatt(L, n > 1 ? n + 2 : n);
  lua_createtable(L, n, 0);  /* new environment for the new pattern */
  if (n > 1) setinstcap(p++, IOpenCapture, 0, Cgroup, 0);
  for (i = j = 1; i <= n; i++) {
    if (lua_isnil(L, i))
      setinstcap(p++, IEmptyCaptureIdx, 0, Cconst, 0);
    else {
      setinstcap(p++, IEmptyCaptureIdx, j, Cconst, 0);
      lua_pushvalue(L, i);
      lua_rawseti(L, -2, j++);
    }
  }
  if (n > 1) setinstcap(p++, ICloseCapture, 0, Cclose, 0);
  lua_setfenv(L, -2);   /* set environment */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1db3c5
movl %eax, %r14d
leal 0x2(%r14), %eax
cmpl $0x2, %r14d
cmovll %r14d, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x1f0978
movq %rax, %r15
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x1dc7bd
cmpl $0x2, %r14d
jl 0x1f39ea
movl $0xd15, (%r15)          # imm = 0xD15
addq $0x8, %r15
testl %r14d, %r14d
movl $0x0, %ebp
movq %r14, (%rsp)
cmovgl %r14d, %ebp
pushq $0x1
popq %r12
cmpl %r13d, %ebp
je 0x1f3a5c
leaq 0x1(%r13), %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1db731
movb $0x14, (%r15,%r13,8)
testl %eax, %eax
je 0x1f3a4a
movw %r12w, 0x2(%r15,%r13,8)
movb $0x2, 0x1(%r15,%r13,8)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1db711
leal 0x1(%r12), %r13d
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movl %r12d, %edx
callq 0x1dcc5f
movl %r13d, %r12d
jmp 0x1f3a57
andw $0x0, 0x2(%r15,%r13,8)
movb $0x2, 0x1(%r15,%r13,8)
movq %r14, %r13
jmp 0x1f39fe
cmpl $0x2, (%rsp)
jl 0x1f3a6a
movl $0x16, (%r15,%r13,8)
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x1dcdc1
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: backref_l
static int backref_l (lua_State *L) {
  Instruction *p = newpatt(L, 1);
  int n = getlabel(L, 1);
  setinstcap(p, IEmptyCaptureIdx, n, Cbackref, 0);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1f0978
movq %rax, %r14
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1f1d2a
movl $0x10314, (%r14)        # imm = 0x10314
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: argcap_l
static int argcap_l (lua_State *L) {
  int n = luaL_checkint(L, 1);
  Instruction *p = newpatt(L, 1);
  luaL_argcheck(L, 0 < n && n <= SHRT_MAX, 1, "invalid argument index");
  setinstcap(p, IEmptyCapture, n, Carg, 0);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x1debd9
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1f0978
movq %rax, %r15
movl %ebx, %eax
decl %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jb 0x1f3b41
leaq 0x176908(%rip), %rdx    # 0x36a43e
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1de6f4
movw $0x413, (%r15)          # imm = 0x413
movw %bx, 0x2(%r15)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: matchtime_l
static int matchtime_l (lua_State *L) {
  int l1 = getpattl(L, 1);
  Instruction *op = newpatt(L, 1 + l1 + 1);
  Instruction *p = op;
  luaL_checktype(L, 2, LUA_TFUNCTION);
  setinstcap(p++, IOpenCapture, value2fenv(L, 2), Cruntime, 0);
  p += addpatt(L, p, 1);
  setinstcap(p, ICloseRunTime, 0, Cclose, 0);
  optimizecaptures(op);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0xc(%rsp), %r15
movl %ebx, %esi
movq %r15, %rdx
callq 0x1f10c5
movslq (%r15), %rsi
addq $0x2, %rsi
movq %r14, %rdi
callq 0x1f0978
movq %rax, %r15
pushq $0x2
popq %rbp
pushq $0x6
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1deaea
leaq 0x8(%r15), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f1d2a
movl $0x10c15, (%r15)        # imm = 0x10C15
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x1f1e11
cltq
movl $0x17, 0x8(%r15,%rax,8)
movq %r15, %rdi
callq 0x1f2762
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: range_l
static int range_l (lua_State *L) {
  int arg;
  int top = lua_gettop(L);
  Instruction *p = newcharset(L);
  for (arg = 1; arg <= top; arg++) {
    int c;
    size_t l;
    const char *r = luaL_checklstring(L, arg, &l);
    luaL_argcheck(L, l == 2, arg, "range must have two characters");
    for (c = (byte)r[0]; c <= (byte)r[1]; c++)
      setchar(p[1].buff, c);
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1db3c5
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1f2997
movq %rax, %r14
xorl %r12d, %r12d
testl %ebp, %ebp
cmovgl %ebp, %r12d
incl %r12d
pushq $0x1
popq %rbp
movl %ebp, %r15d
cmpl %r12d, %r15d
je 0x1f3cac
movq %rbx, %rdi
movl %r15d, %esi
movq %rsp, %rdx
callq 0x1de9c6
movq %rax, %r13
cmpq $0x2, (%rsp)
je 0x1f3c82
movq %rbx, %rdi
movl %r15d, %esi
leaq 0x1767d8(%rip), %rdx    # 0x36a455
callq 0x1de6f4
movzbl (%r13), %eax
movzbl 0x1(%r13), %ecx
cmpl %ecx, %eax
ja 0x1f3ca7
movl %eax, %ecx
andb $0x7, %cl
movl %ebp, %edx
shll %cl, %edx
movl %eax, %ecx
shrl $0x3, %ecx
orb %dl, 0x8(%r14,%rcx)
incl %eax
jmp 0x1f3c87
incl %r15d
jmp 0x1f3c53
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: set_l
static int set_l (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  if (l == 1)
    getpatt(L, 1, NULL);  /* a unit set is equivalent to a literal */
  else {
    Instruction *p = newcharset(L);
    while (l--) {
      setchar(p[1].buff, (byte)(*s));
      s++;
    }
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1de9c6
cmpq $0x1, (%r15)
jne 0x1f3cfa
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1f10c5
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1f2997
subq $0x1, 0x8(%rsp)
jb 0x1f3ced
movzbl (%rbx), %edx
movl %edx, %ecx
andb $0x7, %cl
movb $0x1, %sil
shlb %cl, %sil
shrl $0x3, %edx
orb %sil, 0x8(%rax,%rdx)
incq %rbx
jmp 0x1f3d05
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: nter_l
static int nter_l (lua_State *L) {
  Instruction *p;
  luaL_argcheck(L, !lua_isnoneornil(L, 1), 1, "non-nil value expected");
  p = newpatt(L, 1);
  setinst(p, IOpenCall, value2fenv(L, 1));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1db731
testl %eax, %eax
jg 0x1f3d4d
leaq 0x176732(%rip), %rdx    # 0x36a474
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1de6f4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1f0978
movq %rax, %r14
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1f1d2a
movl $0x1000a, (%r14)        # imm = 0x1000A
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: type_l
static int type_l (lua_State *L) {
  if (testpattern(L, 1))
    lua_pushliteral(L, "pattern");
  else
    lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1f1d66
testl %eax, %eax
je 0x1f3d9a
leaq 0xf8a5b(%rip), %rsi     # 0x2ec7e8
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
jmp 0x1f3da2
movq %rbx, %rdi
callq 0x1dbe22
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: doublestack
static Stack *doublestack (lua_State *L, Stack **stacklimit, int ptop) {
  Stack *stack = getstackbase(L, ptop);
  Stack *newstack;
  int n = *stacklimit - stack;
  int max, newn;
  lua_getfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
  max = lua_tointeger(L, -1);
  lua_pop(L, 1);
  if (n >= max)
    luaL_error(L, "too many pending calls/choices");
  newn = 2*n; if (newn > max) newn = max;
  newstack = (Stack *)lua_newuserdata(L, newn * sizeof(Stack));
  memcpy(newstack, stack, n * sizeof(Stack));
  lua_replace(L, stackidx(ptop));
  *stacklimit = newstack + newn;
  return newstack + n;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
addl $0x4, %ebp
movl %ebp, %esi
callq 0x1dbd9e
movq %rax, %r15
movq %rbx, (%rsp)
movq (%rbx), %rax
subq %r15, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
leaq 0x175cab(%rip), %rdx    # 0x369aa0
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x1dc63b
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x1dbb20
movq %rax, %r13
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x1db3d2
cmpl %r13d, %r12d
jl 0x1f3e31
leaq 0x175e5c(%rip), %rsi    # 0x369c83
movq %r14, %rdi
xorl %eax, %eax
callq 0x1de79c
movl %r12d, %eax
addl %r12d, %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
cltq
imulq $0x18, %rax, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x1dd7d9
movq %rax, %rbx
movslq %r12d, %rax
imulq $0x18, %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x17630
movq %r14, %rdi
movl %ebp, %esi
callq 0x1db535
addq %rbx, %r13
movq (%rsp), %rax
movq %r13, (%rax)
addq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: doublecap
static Capture *doublecap (lua_State *L, Capture *cap, int captop, int ptop) {
  Capture *newc;
  if (captop >= INT_MAX/((int)sizeof(Capture) * 2))
    luaL_error(L, "too many captures");
  newc = (Capture *)lua_newuserdata(L, captop * 2 * sizeof(Capture));
  memcpy(newc, cap, captop * sizeof(Capture));
  lua_replace(L, caplistidx(ptop));
  return newc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x3ffffff, %edx        # imm = 0x3FFFFFF
jl 0x1f3ebd
leaq 0x175213(%rip), %rsi    # 0x3690c6
movq %r14, %rdi
xorl %eax, %eax
callq 0x1de79c
leal (%r12,%r12), %eax
movslq %eax, %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x1dd7d9
movq %rax, %r13
movslq %r12d, %rdx
shlq $0x4, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x17630
addl $0x2, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1db535
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: findopen
static Capture *findopen (Capture *cap) {
  int n = 0;
  for (;;) {
    cap--;
    if (isclosecap(cap)) n++;
    else if (!isfullcap(cap))
      if (n-- == 0) return cap;
  }
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
movq %rax, %rdx
cmpb $0x0, -0x6(%rax)
je 0x1f3f1e
leaq -0x10(%rdx), %rax
cmpb $0x0, -0x5(%rdx)
jne 0x1f3f04
subl $0x1, %ecx
jae 0x1f3f20
jmp 0x1f3f29
incl %ecx
addq $-0x10, %rdx
movq %rdx, %rax
jmp 0x1f3f04
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: pushallvalues
static int pushallvalues (CapState *cs, int addextra) {
  Capture *co = cs->cap;
  int n = 0;
  if (isfullcap(cs->cap++)) {
    pushsubject(cs, co);  /* push whole match */
    return 1;
  }
  while (!isclosecap(cs->cap))
    n += pushcapture(cs);
  if (addextra || n == 0) {  /* need extra? */
    lua_pushlstring(cs->L, co->s, cs->cap->s - co->s);  /* push whole match */
    n++;
  }
  cs->cap++;  /* skip close entry */
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x10(%r15), %rax
movq %rax, (%rdi)
movzbl 0xb(%r15), %edx
testq %rdx, %rdx
je 0x1f3f5b
movq 0x10(%rbx), %rdi
movq (%r15), %rsi
decl %edx
callq 0x1dbe62
pushq $0x1
popq %rbp
jmp 0x1f3fa5
movl %esi, %r14d
xorl %ebp, %ebp
cmpb $0x0, 0xa(%rax)
je 0x1f3f75
movq %rbx, %rdi
callq 0x1f3fb2
addl %eax, %ebp
movq (%rbx), %rax
jmp 0x1f3f60
testl %r14d, %r14d
setne %cl
testl %ebp, %ebp
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1f3f9e
movq 0x10(%rbx), %rdi
movq (%r15), %rsi
movq (%rax), %rdx
subq %rsi, %rdx
callq 0x1dbe62
incl %ebp
movq (%rbx), %rax
addq $0x10, %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: stringcap
static void stringcap (luaL_Buffer *b, CapState *cs) {
  StrAux cps[MAXSTRCAPS];
  int n;
  size_t len, i;
  const char *c;
  updatecache(cs, cs->cap->idx);
  c = lua_tolstring(cs->L, subscache(cs), &len);
  n = getstrcaps(cs, cps, 0) - 1;
  for (i = 0; i < len; i++) {
    if (c[i] != '%' || c[++i] < '0' || c[i] > '9')
      luaL_addchar(b, c[i]);
    else {
      int l = c[i] - '0';
      if (l > n)
        luaL_error(cs->L, "invalid capture index (%d)", l);
      else if (cps[l].isstring)
        luaL_addlstring(b, cps[l].u.s.s, cps[l].u.s.e - cps[l].u.s.s);
      else {
        Capture *curr = cs->cap;
        cs->cap = cps[l].u.cp;
        if (addonestring(b, cs, "capture") == 0)
          luaL_error(cs->L, "no values in capture index %d", l);
        cs->cap = curr;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movswl 0x8(%rax), %esi
cmpl %esi, 0x28(%rbx)
je 0x1f44fd
movq %rbx, %rdi
callq 0x1f46db
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
incl %esi
leaq 0x18(%rsp), %rdx
callq 0x1dbb73
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1f4711
movl %eax, 0xc(%rsp)
leaq 0x2018(%r14), %r13
xorl %ebp, %ebp
cmpq 0x18(%rsp), %rbp
jae 0x1f460a
movb (%r15,%rbp), %al
cmpb $0x25, %al
jne 0x1f4552
movb 0x1(%r15,%rbp), %al
incq %rbp
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x1f4577
movq (%r14), %rcx
cmpq %r13, %rcx
jb 0x1f4569
movq %r14, %rdi
callq 0x1df093
movb (%r15,%rbp), %al
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb %al, (%rcx)
incq %rbp
jmp 0x1f452f
addb $-0x30, %al
movzbl %al, %r12d
cmpl %r12d, 0xc(%rsp)
jle 0x1f45ac
movl %r12d, %eax
imulq $0x18, %rax, %rax
addq %rsp, %rax
addq $0x20, %rax
cmpl $0x0, (%rax)
je 0x1f45c3
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x1deffe
jmp 0x1f4572
movq 0x10(%rbx), %rdi
leaq 0x175c3d(%rip), %rsi    # 0x36a1f4
movl %r12d, %edx
xorl %eax, %eax
callq 0x1de79c
jmp 0x1f4572
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x195c55(%rip), %rdx    # 0x38a234
callq 0x1f47ca
testl %eax, %eax
jne 0x1f45fd
movq 0x10(%rbx), %rdi
leaq 0x175c1c(%rip), %rsi    # 0x36a20f
movl %r12d, %edx
xorl %eax, %eax
callq 0x1de79c
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
jmp 0x1f4572
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: substcap
static void substcap (luaL_Buffer *b, CapState *cs) {
  const char *curr = cs->cap->s;
  if (isfullcap(cs->cap))  /* no nested captures? */
    luaL_addlstring(b, curr, cs->cap->siz - 1);  /* keep original text */
  else {
    cs->cap++;
    while (!isclosecap(cs->cap)) {
      const char *next = cs->cap->s;
      luaL_addlstring(b, curr, next - curr);  /* add text up to capture */
      if (addonestring(b, cs, "replacement") == 0)  /* no capture value? */
        curr = next;  /* keep original text in final result */
      else
        curr = closeaddr(cs->cap - 1);  /* continue after match */
    }
    luaL_addlstring(b, curr, cs->cap->s - curr);  /* add last piece of text */
  }
  cs->cap++;  /* go to next capture */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rcx
movq (%rcx), %r15
movzbl 0xb(%rcx), %edx
testq %rdx, %rdx
je 0x1f4653
decl %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1deffe
addq $0x10, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %rcx
movq %rcx, (%rbx)
leaq 0x120a7d(%rip), %r12    # 0x3150de
movq %r15, %rsi
movb 0xa(%rcx), %bpl
movq (%rcx), %r15
movq %r15, %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x1deffe
testb %bpl, %bpl
je 0x1f4646
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1f47ca
movq (%rbx), %rcx
testl %eax, %eax
je 0x1f4661
movq -0x10(%rcx), %rax
movzbl -0x5(%rcx), %edx
leaq (%rax,%rdx), %r15
decq %r15
jmp 0x1f4661
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: nextcap
static Capture *nextcap (Capture *cap) {
  if (isfullcap(cap)) return cap + 1;
  else {
    int n = 0;
    for (;;) {
      cap++;
      if (isclosecap(cap)) {
        if (n-- == 0) return cap + 1;
      }
      else if (!isfullcap(cap)) n++;
    }
  }
}

// Assembly:
movq %rdi, %rax
cmpb $0x0, 0xb(%rdi)
je 0x1f46b2
addq $0x10, %rax
retq
addq $0x20, %rax
xorl %ecx, %ecx
pushq $-0x1
popq %rdx
cmpb $0x0, -0x6(%rax)
je 0x1f46cd
xorl %esi, %esi
cmpb $0x0, -0x5(%rax)
sete %sil
jmp 0x1f46d3
movl %edx, %esi
testl %ecx, %ecx
je 0x1f46b1
addl %esi, %ecx
addq $0x10, %rax
jmp 0x1f46bb
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: getstrcaps
static int getstrcaps (CapState *cs, StrAux *cps, int n) {
  int k = n++;
  cps[k].isstring = 1;
  cps[k].u.s.s = cs->cap->s;
  if (!isfullcap(cs->cap++)) {
    while (!isclosecap(cs->cap)) {
      if (n >= MAXSTRCAPS)  /* too many captures? */
        cs->cap = nextcap(cs->cap);  /* skip it */
      else if (captype(cs->cap) == Csimple)
        n = getstrcaps(cs, cps, n);
      else {
        cps[n].isstring = 0;
        cps[n].u.cp = cs->cap;
        cs->cap = nextcap(cs->cap);
        n++;
      }
    }
    cs->cap++;  /* skip close */
  }
  cps[k].u.s.e = closeaddr(cs->cap - 1);
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movslq %edx, %rax
incl %ebx
imulq $0x18, %rax, %rax
leaq (%rsi,%rax), %r12
movl $0x1, (%rsi,%rax)
movq (%rdi), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rsi,%rax)
movq (%rdi), %rcx
leaq 0x10(%rcx), %rax
movq %rax, (%rdi)
cmpb $0x0, 0xb(%rcx)
jne 0x1f47a9
movq %rsi, %r15
movq %rdi, %r14
movb 0xa(%rax), %cl
testb %cl, %cl
je 0x1f47a2
cmpl $0xa, %ebx
jl 0x1f4769
movq %rax, %rdi
callq 0x1f46a4
movq %rax, (%r14)
jmp 0x1f4750
cmpb $0x5, %cl
jne 0x1f4782
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x1f4711
movl %eax, %ebx
movq (%r14), %rax
jmp 0x1f4750
movslq %ebx, %rcx
imulq $0x18, %rcx, %rcx
andl $0x0, (%r15,%rcx)
movq %rax, 0x8(%r15,%rcx)
movq (%r14), %rdi
callq 0x1f46a4
movq %rax, (%r14)
incl %ebx
jmp 0x1f4750
addq $0x10, %rax
movq %rax, (%r14)
movq -0x10(%rax), %rcx
movzbl -0x5(%rax), %eax
addq %rcx, %rax
decq %rax
movq %rax, 0x10(%r12)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: addonestring
static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) {
  switch (captype(cs->cap)) {
    case Cstring:
      stringcap(b, cs);  /* add capture directly to buffer */
      return 1;
    case Csubst:
      substcap(b, cs);  /* add capture directly to buffer */
      return 1;
    default: {
      lua_State *L = cs->L;
      int n = pushcapture(cs);
      if (n > 0) {
        if (n > 1) lua_pop(L, n - 1);  /* only one result */
        if (!lua_isstring(L, -1))
          luaL_error(L, "invalid %s value (a %s)", what, luaL_typename(L, -1));
        luaL_addvalue(b);
      }
      return n;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movzbl 0xa(%rax), %eax
cmpl $0xa, %eax
je 0x1f47ef
cmpl $0x9, %eax
jne 0x1f47fc
movq %rbx, %rdi
callq 0x1f44d2
jmp 0x1f47f7
movq %rbx, %rdi
callq 0x1f461c
pushq $0x1
popq %rbp
jmp 0x1f4865
movq %rdx, %r14
movq 0x10(%rsi), %r15
movq %rsi, %rdi
callq 0x1f3fb2
movl %eax, %ebp
testl %eax, %eax
jle 0x1f4865
cmpl $0x1, %ebp
je 0x1f4822
movl %ebp, %esi
negl %esi
movq %r15, %rdi
callq 0x1db3d2
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x1db803
testl %eax, %eax
jne 0x1f485d
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x1db731
movq %r15, %rdi
movl %eax, %esi
callq 0x1db74a
leaq 0x1759e0(%rip), %rsi    # 0x36a22d
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1de79c
movq %rbx, %rdi
callq 0x1df182
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: printcharset
static void printcharset (const Charset st) {
  int i;
  printf("[");
  for (i = 0; i <= UCHAR_MAX; i++) {
    int first = i;
    while (testchar(st, i) && i <= UCHAR_MAX) i++;
    if (i - 1 == first)  /* unary range? */
      printf("(%02x)", first);
    else if (i - 1 > first)  /* non-empty range? */
      printf("(%02x-%02x)", first, i - 1);
  }
  printf("]");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x5b
popq %rdi
callq 0x179c0
pushq $0x1
popq %rbp
leaq 0x175ae1(%rip), %r14    # 0x36a3c7
leaq 0x175ae1(%rip), %r15    # 0x36a3ce
xorl %r12d, %r12d
cmpl $0xff, %r12d
jg 0x1f494d
movl %r12d, %esi
xorl %eax, %eax
leal (%rsi,%rax), %edx
movl %edx, %ecx
andb $0x7, %cl
movl %ebp, %edi
shll %cl, %edi
incl %eax
cmpl $0xff, %edx
jg 0x1f4922
sarl $0x3, %edx
movslq %edx, %rcx
movzbl (%rbx,%rcx), %ecx
andl %ecx, %edi
jne 0x1f48fe
leal (%rsi,%rax), %r12d
cmpl $0x2, %eax
jne 0x1f4937
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
jmp 0x1f48f0
leal (%rsi,%rax), %edx
addl $-0x2, %edx
cmpl %esi, %edx
jle 0x1f48f0
movq %r15, %rdi
xorl %eax, %eax
callq 0x17070
jmp 0x1f48f0
pushq $0x5d
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x179c0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: createcat
static void createcat (lua_State *L, const char *catname, int (catf) (int)) {
  Instruction *p = newcharset(L);
  int i;
  for (i = 0; i < CHAR_MAX; i++)
    if (catf(i)) setchar(p[1].buff, i);
  lua_setfield(L, -2, catname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f2997
movq %rax, %r12
xorl %ebp, %ebp
pushq $0x1
popq %r13
cmpl $0x7f, %ebp
je 0x1f49a5
movl %ebp, %edi
callq *%r15
testl %eax, %eax
je 0x1f49a1
movl %ebp, %ecx
andb $0x7, %cl
movl %r13d, %eax
shll %cl, %eax
movl %ebp, %ecx
shrl $0x3, %ecx
orb %al, 0x8(%r12,%rcx)
incl %ebp
jmp 0x1f497f
pushq $-0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1dcb19
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_calend
uint32_t bam_calend(const bam1_core_t *c, const uint32_t *cigar)
{
	uint32_t k, end;
	end = c->pos;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		if (op == BAM_CMATCH || op == BAM_CDEL || op == BAM_CREF_SKIP)
			end += cigar[k] >> BAM_CIGAR_SHIFT;
	}
	return end;
}

// Assembly:
movl 0x4(%rdi), %eax
movzwl 0xe(%rdi), %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1f4a01
movl (%rsi,%rdx,4), %edi
movl %edi, %r8d
andl $0xf, %r8d
movl %edi, %r9d
shrl $0x4, %r9d
cmpl $0x3, %r8d
movl $0x0, %r8d
cmovel %r9d, %r8d
testb $0xd, %dil
cmovel %r9d, %r8d
addl %r8d, %eax
incq %rdx
jmp 0x1f49cd
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_cigar2qlen
int32_t bam_cigar2qlen(const bam1_core_t *c, const uint32_t *cigar)
{
	uint32_t k;
	int32_t l = 0;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		if (op == BAM_CMATCH || op == BAM_CINS || op == BAM_CSOFT_CLIP || op == BAM_CEQUAL || op == BAM_CDIFF)
			l += cigar[k] >> BAM_CIGAR_SHIFT;
	}
	return l;
}

// Assembly:
movzwl 0xe(%rdi), %ecx
xorl %edx, %edx
movl $0x193, %edi            # imm = 0x193
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x1f4a37
movl (%rsi,%rdx,4), %r8d
movl %r8d, %r9d
andl $0xf, %r9d
cmpl $0x8, %r9d
ja 0x1f4a32
btl %r9d, %edi
jae 0x1f4a32
shrl $0x4, %r8d
addl %r8d, %eax
incq %rdx
jmp 0x1f4a0f
retq