LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: repeats
static Instruction *repeats (lua_State *L, Instruction *p1, int l1, int n) {
  /* e; ...; e; choice L1; L2: e; partialcommit L2; L1: ... */
  int i;
  Instruction *op = newpatt(L, (n + 1)*l1 + 2);
  Instruction *p = op;
  if (!verify(L, p1, p1, p1 + l1, 0, 0))
    luaL_error(L, "loop body may accept empty string");
  for (i = 0; i < n; i++) {
    p += addpatt(L, p, 1);
  }
  setinst(p++, IChoice, 1 + l1 + 1);
  p += addpatt(L, p, 1);
  setinst(p, IPartialCommit, -l1);
  return op;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %eax
addl $0x1, %eax
imull 0x24(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x28(%rsp), %rcx
movslq 0x24(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x35faa0
cmpl $0x0, %eax
jne 0x360ff4
movq 0x30(%rsp), %rdi
leaq 0x23bfef(%rip), %rsi    # 0x59cfdc
movb $0x0, %al
callq 0x33a320
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x36103d
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x360ffc
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edx
addl $0x1, %edx
addl $0x1, %edx
movl $0x7, %esi
xorl %ecx, %ecx
callq 0x35dbc0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %edx, %edx
subl 0x24(%rsp), %edx
movl $0xc, %esi
xorl %ecx, %ecx
callq 0x35dbc0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: optionalheadfail
static void optionalheadfail (lua_State *L, int l1, int n) {
  Instruction *op = newpatt(L, n * l1);
  Instruction *p = op;
  int i;
  for (i = 0; i < n; i++) {
    p += addpatt(L, p, 1);
    check2test(p - l1, (n - i)*l1);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %eax
imull 0x1c(%rsp), %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x3614e7
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x1c(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x18(%rsp), %esi
subl 0x4(%rsp), %esi
imull 0x1c(%rsp), %esi
callq 0x3609f0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x36147e
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: optionals
static void optionals (lua_State *L, int l1, int n) {
  /* choice L1; e; partialcommit L2; L2: ... e; L1: commit L3; L3: ... */
  int i;
  Instruction *op = newpatt(L, n*(l1 + 1) + 1);
  Instruction *p = op;
  setinst(p++, IChoice, 1 + n*(l1 + 1));
  for (i = 0; i < n; i++) {
    p += addpatt(L, p, 1);
    setinst(p++, IPartialCommit, 1);
  }
  setinst(p - 1, ICommit, 1);  /* correct last commit */
  optimizechoice(op);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movl 0x18(%rsp), %edx
movl 0x1c(%rsp), %eax
addl $0x1, %eax
imull %eax, %edx
addl $0x1, %edx
movl $0x7, %esi
xorl %ecx, %ecx
callq 0x35dbc0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x3615bf
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movl $0xc, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x35dbc0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x361561
movq (%rsp), %rdi
addq $-0x8, %rdi
movl $0xb, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x35dbc0
movq 0x8(%rsp), %rdi
callq 0x360a70
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
movl %eax, %ecx
leaq 0x23b507(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %ecx
andl $0x4, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x13(%rsp)
je 0x361653
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movswl 0x2(%rax,%rcx,8), %eax
cmpl $0x0, %eax
sete %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x361660
jmp 0x3616e1
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0x0, %eax
jne 0x361688
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movzbl 0x1(%rax,%rcx,8), %eax
movl %eax, 0xc(%rsp)
jmp 0x361693
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x361693
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
addl 0x14(%rsp), %eax
movl $0xf, %ecx
subl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jle 0x3616b2
jmp 0x3616e1
movl 0x14(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x35f7b0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x361612
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x35db20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x2, (%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x2(%rax)
movl $0x0, 0x4(%rsp)
cmpl $0x20, 0x4(%rsp)
jge 0x36175b
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x361738
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
leaq 0x44(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
xorl %esi, %esi
leaq 0x40(%rsp), %rdx
callq 0x3615f0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x44(%rsp), %eax
jne 0x361833
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x3618f0
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
movl 0x4c(%rsp), %ecx
movl 0x40(%rsp), %eax
shll $0x4, %eax
orl %eax, %ecx
movl $0x12, %esi
callq 0x35dbc0
jmp 0x3618d9
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %eax
addl $0x1, %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x3618f0
movq 0x8(%rsp), %rdi
movl %eax, %edx
movl 0x4c(%rsp), %ecx
orl $0x0, %ecx
movl $0x15, %esi
callq 0x35dbc0
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x16, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
movq 0x18(%rsp), %rdi
callq 0x3610b0
movl $0x1, %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: matchl
static int matchl (lua_State *L) {
  Capture capture[INITCAPSIZE];
  const char *r;
  size_t l;
  Instruction *p = getpatt(L, 1, NULL);
  const char *s = luaL_checklstring(L, SUBJIDX, &l);
  int ptop = lua_gettop(L);
  lua_Integer ii = luaL_optinteger(L, 3, 1);
  size_t i = (ii > 0) ?
             (((size_t)ii <= l) ? (size_t)ii - 1 : l) :
             (((size_t)-ii <= l) ? l - ((size_t)-ii) : 0);
  lua_pushnil(L);  /* subscache */
  lua_pushlightuserdata(L, capture);  /* caplistidx */
  lua_getfenv(L, 1);  /* penvidx */
  r = match(L, s, s + i, s + l, p, capture, ptop);
  if (r == NULL) {
    lua_pushnil(L);
    return 1;
  }
  return getcaptures(L, s, r, ptop);
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x268(%rsp)
movq 0x268(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x35e4f0
movq %rax, 0x48(%rsp)
movq 0x268(%rsp), %rdi
movl $0x2, %esi
leaq 0x50(%rsp), %rdx
callq 0x33a6b0
movq %rax, 0x40(%rsp)
movq 0x268(%rsp), %rdi
callq 0x333eb0
movl %eax, 0x3c(%rsp)
movq 0x268(%rsp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x33aa70
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jle 0x3619dd
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
ja 0x3619c7
movq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x3619d1
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x361a14
xorl %eax, %eax
subq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
ja 0x361a01
movq 0x50(%rsp), %rax
xorl %ecx, %ecx
subq 0x30(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x361a0a
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x361a0a
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x268(%rsp), %rdi
callq 0x335470
movq 0x268(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x336160
movq 0x268(%rsp), %rdi
movl $0x1, %esi
callq 0x3369c0
movq 0x268(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq 0x28(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
leaq 0x60(%rsp), %r9
movl 0x3c(%rsp), %eax
movl %eax, (%rsp)
callq 0x362760
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x361aad
movq 0x268(%rsp), %rdi
callq 0x335470
movl $0x1, 0x274(%rsp)
jmp 0x361acf
movq 0x268(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rdx
movl 0x3c(%rsp), %ecx
callq 0x363800
movl %eax, 0x274(%rsp)
movl 0x274(%rsp), %eax
addq $0x278, %rsp            # imm = 0x278
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x35e4f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3369c0
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x35fa50
movl %eax, 0x14(%rsp)
leaq 0x2326d0(%rip), %rdi    # 0x5941fa
movb $0x0, %al
callq 0x19070
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x361bfb
movl 0x10(%rsp), %esi
leaq 0x23b8af(%rip), %rdi    # 0x59d401
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x336650
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3347b0
cmpl $0x0, %eax
je 0x361ba6
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq %rax, %rsi
leaq 0x23b86a(%rip), %rdi    # 0x59d407
movb $0x0, %al
callq 0x19070
jmp 0x361bdc
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x334620
movq %rax, %rsi
leaq 0x23b832(%rip), %rdi    # 0x59d407
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x361b39
leaq 0x1ebc4a(%rip), %rdi    # 0x54d84c
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rdi
callq 0x365080
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3345d0
cmpl $0x0, %eax
jg 0x361c55
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x333ed0
movq (%rsp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x336790
jmp 0x361c76
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x33a880
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x333ed0
movq (%rsp), %rdi
leaq 0x23b871(%rip), %rsi    # 0x59d4f2
movq 0x2da2f8(%rip), %rdx    # 0x63bf80
callq 0x365490
movq (%rsp), %rdi
leaq 0x252c9e(%rip), %rsi    # 0x5b4936
movq 0x2da319(%rip), %rdx    # 0x63bfb8
callq 0x365490
movq (%rsp), %rdi
leaq 0x23b849(%rip), %rsi    # 0x59d4f8
movq 0x2da2fa(%rip), %rdx    # 0x63bfb0
callq 0x365490
movq (%rsp), %rdi
leaq 0x23b83f(%rip), %rsi    # 0x59d505
movq 0x2da29b(%rip), %rdx    # 0x63bf68
callq 0x365490
movq (%rsp), %rdi
leaq 0x220df2(%rip), %rsi    # 0x582acf
movq 0x2da28c(%rip), %rdx    # 0x63bf70
callq 0x365490
movq (%rsp), %rdi
leaq 0x23a4d7(%rip), %rsi    # 0x59c1cb
movq 0x2da295(%rip), %rdx    # 0x63bf90
callq 0x365490
movq (%rsp), %rdi
leaq 0x1cd43d(%rip), %rsi    # 0x52f148
movq 0x2da2ce(%rip), %rdx    # 0x63bfe0
callq 0x365490
movq (%rsp), %rdi
leaq 0x23b7dc(%rip), %rsi    # 0x59d4fe
movq 0x2da2cf(%rip), %rdx    # 0x63bff8
callq 0x365490
movq (%rsp), %rdi
leaq 0x1fd85f(%rip), %rsi    # 0x55f598
movq 0x2da1f0(%rip), %rdx    # 0x63bf30
callq 0x365490
movq (%rsp), %rdi
leaq 0x2595dd(%rip), %rsi    # 0x5bb32d
movq 0x2da201(%rip), %rdx    # 0x63bf58
callq 0x365490
movq (%rsp), %rdi
leaq 0x23b79d(%rip), %rsi    # 0x59d504
movq 0x2da1d2(%rip), %rdx    # 0x63bf40
callq 0x365490
movl $0x1, %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x33aa70
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x333ed0
movq (%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x23ae00(%rip), %rdx    # 0x59cbb8
callq 0x336d90
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x333eb0
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x24(%rsp)
jle 0x362065
movl 0x24(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0x36206d
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %edx, %edx
callq 0x336790
cmpl $0x1, 0x24(%rsp)
jle 0x3620bc
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl $0x15, %esi
xorl %edx, %edx
movl $0xd, %ecx
callq 0x35dbc0
movl $0x1, 0x28(%rsp)
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0x362171
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x3345d0
cmpl $0x0, %eax
jne 0x362111
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl $0x14, %esi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x35dbc0
jmp 0x36215f
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl 0x28(%rsp), %edx
movl $0x14, %esi
movl $0x2, %ecx
callq 0x35dbc0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x334560
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x337050
jmp 0x362161
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3620cc
cmpl $0x1, 0x24(%rsp)
jle 0x362197
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl $0x16, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x337320
movl $0x1, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: group_l
static int group_l (lua_State *L) {
  if (lua_isnoneornil(L, 2))
    return capture_aux(L, Cgroup, 0);
  else {
    luaL_checkstring(L, 2);
    return capture_aux(L, Cgroup, 2);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3345d0
cmpl $0x0, %eax
jg 0x3621e4
movq 0x8(%rsp), %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x361770
movl %eax, 0x14(%rsp)
jmp 0x36220f
movq 0x8(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x33a6b0
movq 0x8(%rsp), %rdi
movl $0xd, %esi
movl $0x2, %edx
callq 0x361770
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x35db20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x3618f0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
movl $0x14, %esi
movl $0x3, %ecx
callq 0x35dbc0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x33aa10
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x35db20
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpl 0x1c(%rsp), %eax
jge 0x362308
movb $0x1, %al
cmpl $0x7fff, 0x1c(%rsp)     # imm = 0x7FFF
movb %al, 0xf(%rsp)
jle 0x362328
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x23b23d(%rip), %rdx    # 0x59d556
callq 0x33a1f0
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x13, %esi
movl $0x4, %ecx
callq 0x35dbc0
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3655a0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x33a880
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x35f1b0
movq (%rsp), %rdi
movl %eax, %edx
movl $0x15, %esi
movl $0xc, %ecx
callq 0x35dbc0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x17, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
movq 0x10(%rsp), %rdi
callq 0x3610b0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x333eb0
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x361700
movq %rax, 0x20(%rsp)
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jg 0x362589
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq 0x33a6b0
movq %rax, 0x8(%rsp)
movb $0x1, %al
cmpq $0x2, 0x10(%rsp)
movb %al, 0x7(%rsp)
je 0x362521
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x23b05b(%rip), %rdx    # 0x59d56d
callq 0x33a1f0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jg 0x362577
movl 0x1c(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0x8(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0x8(%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x362531
jmp 0x362579
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3624ce
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
callq 0x33a6b0
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x18(%rsp)
jne 0x3625df
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x35e4f0
jmp 0x362647
movq 0x20(%rsp), %rdi
callq 0x361700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rsp)
cmpq $0x0, %rax
je 0x362645
movq 0x10(%rsp), %rax
movzbl (%rax), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0x8(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0x8(%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3625ee
jmp 0x362647
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3345d0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
jg 0x3626a5
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x23aef6(%rip), %rdx    # 0x59d58c
callq 0x33a1f0
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x35db20
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x35f1b0
movq 0x8(%rsp), %rdi
movl %eax, %edx
movl $0xa, %esi
xorl %ecx, %ecx
callq 0x35dbc0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x35f210
cmpl $0x0, %eax
je 0x36272f
movq (%rsp), %rdi
leaq 0x1bb14f(%rip), %rsi    # 0x51d872
movl $0x7, %edx
callq 0x335540
jmp 0x362738
movq (%rsp), %rdi
callq 0x335470
movl $0x1, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: getcaptures
static int getcaptures (lua_State *L, const char *s, const char *r, int ptop) {
  Capture *capture = (Capture *)lua_touserdata(L, caplistidx(ptop));
  int n = 0;
  if (!isclosecap(capture)) {  /* is there any capture? */
    CapState cs;
    cs.ocap = cs.cap = capture; cs.L = L;
    cs.s = s; cs.valuecached = 0; cs.ptop = ptop;
    do {  /* collect their values */
      n += pushcapture(&cs);
    } while (!isclosecap(cs.cap));
  }
  if (n == 0) {  /* no capture values? */
    lua_pushinteger(L, r - s + 1);  /* return only end position */
    n = 1;
  }
  return n;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq 0x60(%rsp), %rdi
movl 0x4c(%rsp), %esi
addl $0x2, %esi
callq 0x335300
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
je 0x36389f
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x363ea0
addl 0x3c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x8(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x363876
jmp 0x36389f
cmpl $0x0, 0x3c(%rsp)
jne 0x3638c9
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
subq %rax, %rsi
addq $0x1, %rsi
callq 0x3354f0
movl $0x1, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
addl $0x4, %esi
callq 0x335300
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x239281(%rip), %rdx    # 0x59cbb8
callq 0x336410
movq 0x30(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x334e60
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jl 0x36397b
movq 0x30(%rsp), %rdi
leaq 0x239427(%rip), %rsi    # 0x59cd9b
movb $0x0, %al
callq 0x33a320
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jle 0x363997
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x4(%rsp), %rax
imulq $0x18, %rax, %rsi
callq 0x338720
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rdx
callq 0x19610
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
addl $0x4, %esi
callq 0x334260
movq 0x10(%rsp), %rcx
movslq 0x4(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: runtimecap
static int runtimecap (lua_State *L, Capture *close, Capture *ocap,
                       const char *o, const char *s, int ptop) {
  CapState cs;
  int n;
  Capture *open = findopen(close);
  assert(captype(open) == Cruntime);
  close->kind = Cclose;
  close->s = s;
  cs.ocap = ocap; cs.cap = open; cs.L = L;
  cs.s = o; cs.valuecached = 0; cs.ptop = ptop;
  luaL_checkstack(L, 4, "too many runtime captures");
  pushluaval(&cs);
  lua_pushvalue(L, SUBJIDX);  /* push original subject */
  lua_pushinteger(L, s - o + 1);  /* current position */
  n = pushallvalues(&cs, 0);
  lua_call(L, n + 2, LUA_MULTRET);
  return close - open;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movq 0x68(%rsp), %rdi
callq 0x363d20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0xc, %eax
jne 0x363a51
jmp 0x363a70
leaq 0x2397f0(%rip), %rdi    # 0x59d248
leaq 0x23919b(%rip), %rsi    # 0x59cbfa
movl $0x7f2, %edx            # imm = 0x7F2
leaq 0x2397f7(%rip), %rcx    # 0x59d262
callq 0x19490
movq 0x68(%rsp), %rax
movb $0x0, 0xa(%rax)
movq 0x50(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
movl $0x4, %esi
leaq 0x2397e6(%rip), %rdx    # 0x59d2b5
callq 0x33a840
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
addl $0x3, %esi
movq 0x18(%rsp), %rax
movswl 0x8(%rax), %edx
callq 0x336650
movq 0x70(%rsp), %rdi
movl $0x2, %esi
callq 0x334560
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
subq %rax, %rsi
addq $0x1, %rsi
callq 0x3354f0
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x363d90
movl %eax, 0x14(%rsp)
movq 0x70(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x337460
movq 0x68(%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x3ffffff, 0x14(%rsp)  # imm = 0x3FFFFFF
jl 0x363b93
movq 0x20(%rsp), %rdi
leaq 0x2386b5(%rip), %rsi    # 0x59c241
movb $0x0, %al
callq 0x33a320
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %eax
shll %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x338720
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
callq 0x19610
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
addl $0x2, %esi
callq 0x334260
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: adddyncaptures
static void adddyncaptures (const char *s, Capture *base, int n, int fd) {
  int i;
  assert(base[0].kind == Cruntime && base[0].siz == 0);
  base[0].idx = fd;  /* first returned capture */
  for (i = 1; i < n; i++) {  /* add extra captures */
    base[i].siz = 1;  /* mark it as closed */
    base[i].s = s;
    base[i].kind = Cruntime;
    base[i].idx = fd + i;  /* stack index */
  }
  base[n].kind = Cclose;  /* add closing entry */
  base[n].siz = 1;
  base[n].s = s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0xc, %eax
jne 0x363c24
movq 0x18(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x363c24
jmp 0x363c43
leaq 0x239772(%rip), %rdi    # 0x59d39d
leaq 0x238fc8(%rip), %rsi    # 0x59cbfa
movl $0x1a8, %edx            # imm = 0x1A8
leaq 0x23978c(%rip), %rcx    # 0x59d3ca
callq 0x19490
movl 0x10(%rsp), %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x8(%rax)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x363cd5
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0xb(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0xc, 0xa(%rax)
movl 0x10(%rsp), %eax
addl 0xc(%rsp), %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x363c5b
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0xa(%rax)
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0xb(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
addq $-0x10, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x363d56
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x363d80
movq -0x8(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x363d7e
movl -0xc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rsp)
cmpl $0x0, %eax
jne 0x363d7c
movq -0x8(%rsp), %rax
retq
jmp 0x363d7e
jmp 0x363d80
jmp 0x363d2d
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, (%rcx)
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
je 0x363dff
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movzbl 0xb(%rax), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x335540
movl $0x1, 0x24(%rsp)
jmp 0x363e8b
jmp 0x363e01
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x363e1b
jmp 0x363e2f
movq 0x18(%rsp), %rdi
callq 0x363ea0
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x363e01
cmpl $0x0, 0x14(%rsp)
jne 0x363e3d
cmpl $0x0, 0x4(%rsp)
jne 0x363e74
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
subq %rax, %rdx
callq 0x335540
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
je 0x3645a5
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xb(%rax), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x33b0f0
jmp 0x36466f
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3645ce
jmp 0x36464d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq %rax, %rdx
callq 0x33b0f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x1e2a0b(%rip), %rdx    # 0x547016
callq 0x364dd0
cmpl $0x0, %eax
jne 0x364621
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x364648
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movzbl -0x5(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3645b4
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
subq %rax, %rdx
callq 0x33b0f0
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
je 0x3646b3
movq -0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rsp)
jmp 0x364718
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x3646fb
movl -0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rsp)
cmpl $0x0, %eax
jne 0x3646f9
movq -0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rsp)
jmp 0x364718
jmp 0x364716
movq -0x10(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x364714
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x364716
jmp 0x3646bb
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: backrefcap
static int backrefcap (CapState *cs) {
  int n;
  Capture *curr = cs->cap;
  pushluaval(cs);  /* reference name */
  cs->cap = findback(cs, curr);
  n = pushallvalues(cs, 0);
  cs->cap = curr + 1;
  return n;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x18(%rax), %esi
addl $0x3, %esi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movswl 0x8(%rax), %edx
callq 0x336650
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x364f10
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x363d90
movl %eax, 0xc(%rsp)
movq (%rsp), %rcx
addq $0x10, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: tablecap
static int tablecap (CapState *cs) {
  lua_State *L = cs->L;
  int n = 0;
  lua_newtable(L);
  if (isfullcap(cs->cap++))
    return 1;  /* table is empty */
  while (!isclosecap(cs->cap)) {
    if (captype(cs->cap) == Cgroup && cs->cap->idx != 0) {  /* named group? */
      int k;
      pushluaval(cs);  /* push group name */
      k = pushallvalues(cs, 0);
      if (k == 0) {  /* no value? */
        lua_pop(L, 1);  /* remove group name */
        continue;  /* and go on */
      }
      else if (k > 1)
        lua_pop(L, k - 1);  /* keep just one value */
      lua_settable(L, -3);
    }
    else {
      int i;
      int k = pushcapture(cs);
      for (i = k; i > 0; i--)
        lua_rawseti(L, -(i + 1), n + i);
      n += k;
    }
  }
  cs->cap++;  /* skip close entry */
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x336790
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, (%rcx)
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
je 0x3647f5
movl $0x1, 0x24(%rsp)
jmp 0x36492c
jmp 0x3647f7
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x364814
jmp 0x364915
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0xd, %eax
jne 0x3648c0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x3648c0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x18(%rax), %esi
addl $0x3, %esi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movswl 0x8(%rax), %edx
callq 0x336650
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x363d90
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x36488e
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
jmp 0x3647f7
cmpl $0x1, 0x8(%rsp)
jle 0x3648ad
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
subl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
subl $0x1, %esi
callq 0x333ed0
jmp 0x3648af
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x336ae0
jmp 0x364910
movq 0x18(%rsp), %rdi
callq 0x363ea0
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jle 0x364905
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
movl 0xc(%rsp), %edx
addl 0x4(%rsp), %edx
callq 0x337050
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3648d4
movl (%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x3647f7
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: functioncap
static int functioncap (CapState *cs) {
  int n;
  int top = lua_gettop(cs->L);
  pushluaval(cs);
  n = pushallvalues(cs, 0);
  lua_call(cs->L, n, LUA_MULTRET);
  return lua_gettop(cs->L) - top;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x333eb0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x18(%rax), %esi
addl $0x3, %esi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movswl 0x8(%rax), %edx
callq 0x336650
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x363d90
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0xc(%rsp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x337460
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x333eb0
subl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nop