LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: newpatt
static Instruction *newpatt (lua_State *L, size_t n) {
  Instruction *p;
  if (n >= MAXPATTSIZE - 1)
    luaL_error(L, "pattern too big");
  p = (Instruction *)lua_newuserdata(L, (n + 1) * sizeof(Instruction));
  luaL_getmetatable(L, PATTERN_T);
  lua_setmetatable(L, -2);
  setinst(p + n, IEnd, 0);
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x7ff4, %rsi           # imm = 0x7FF4
jb 0x245ff2
leaq 0x18cdfc(%rip), %rsi    # 0x3d2de4
movq %r14, %rdi
xorl %eax, %eax
callq 0x230abd
leaq 0x8(,%rbx,8), %rsi
movq %r14, %rdi
callq 0x22f9f1
movq %rax, %r15
leaq 0x18cda7(%rip), %rdx    # 0x3d2db3
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e6f4
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ee93
movl $0x6, (%r15,%rbx,8)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: union_l
static int union_l (lua_State *L) {
  int l1, l2;
  int size = 0;
  Instruction *p1 = getpatt(L, 1, &l1);
  Instruction *p2 = getpatt(L, 2, &l2);
  CharsetTag st2;
  if (isfail(p1))  /* check for simple identities */
    lua_pushvalue(L, 2);  /* fail / a == a */
  else if (isfail(p2) || issucc(p1))
    lua_pushvalue(L, 1);  /* a / fail == a; true / a == true */
  else {
    tocharset(p2, &st2);
    separateparts(L, p1, l1, l2, &size, &st2);
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x0, (%rsp)
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x246779
movq %rax, %r14
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x246779
movb (%r14), %cl
cmpb $0xf, %cl
jne 0x246080
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x2460bd
cmpb $0x6, %cl
je 0x2460b5
cmpb $0xf, (%rax)
je 0x2460b5
leaq 0xc(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x246ec3
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %ecx
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r9
callq 0x246f7a
jmp 0x2460c2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22d798
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: diff_l
static int diff_l (lua_State *L) {
  int l1, l2;
  Instruction *p1 = getpatt(L, 1, &l1);
  Instruction *p2 = getpatt(L, 2, &l2);
  CharsetTag st1, st2;
  if (tocharset(p1, &st1) == ISCHARSET && tocharset(p2, &st2) == ISCHARSET) {
    Instruction *p = newcharset(L);
    loopset(i, p[1].buff[i] = st1.cs[i] & ~st2.cs[i]);
  }
  else if (isheadfail(p2)) {
    Instruction *p = newpatt(L, l2 + 1 + l1);
    p += addpatt(L, p, 2);
    check2test(p - l2, l2 + 1);
    setinst(p++, IFail, 0);
    addpatt(L, p, 1);
  }
  else {  /* !e2 . e1 */
    /* !e -> choice L1; e; failtwice; L1: ... */
    Instruction *p = newpatt(L, 1 + l2 + 1 + l1);
    Instruction *pi = p;
    setinst(p++, IChoice, 1 + l2 + 1);
    p += addpatt(L, p, 2);
    setinst(p++, IFailTwice, 0);
    addpatt(L, p, 1);
    optimizechoice(pi);
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
callq 0x246779
movq %rax, %r15
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x246779
movq %rax, %r14
leaq 0x2c(%rsp), %rsi
movq %r15, %rdi
callq 0x246ec3
cmpl $0x1, %eax
jne 0x24642b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x246ec3
cmpl $0x1, %eax
jne 0x24642b
movl $0x5, %esi
movq %rbx, %rdi
callq 0x245fcd
movb $0x2, (%rax)
movw $0x0, 0x2(%rax)
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
xorl %eax, %eax
movups 0x30(%rsp,%rax), %xmm0
movups 0xc(%rsp,%rax), %xmm1
andnps %xmm0, %xmm1
movups %xmm1, (%rcx,%rax)
addq $0x10, %rax
cmpq $0x20, %rax
jne 0x24640b
jmp 0x2464f5
movq %r14, %rdi
callq 0x247ec7
movl (%rsp), %ecx
movl 0x4(%rsp), %edx
testl %eax, %eax
je 0x246499
leal (%rcx,%rdx), %eax
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x2475f9
movslq %eax, %r15
leaq (%r14,%r15,8), %rdi
movslq (%rsp), %rax
leal 0x1(%rax), %esi
shlq $0x3, %rax
subq %rax, %rdi
callq 0x247f53
leaq (%r14,%r15,8), %rsi
addq $0x8, %rsi
movl $0xf, -0x8(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2475f9
jmp 0x2464f5
leal (%rcx,%rdx), %eax
addl $0x2, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r14
leaq 0x8(%rax), %rsi
movl (%rsp), %eax
movw $0x7, (%r14)
addl $0x2, %eax
movw %ax, 0x2(%r14)
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2475f9
cltq
leaq (%r14,%rax,8), %rsi
addq $0x10, %rsi
movl $0xe, -0x8(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2475f9
movq %r14, %rdi
callq 0x247f90
movl $0x1, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: concat_l
static int concat_l (lua_State *L) {
  /* p1; p2; */
  int l1, l2;
  Instruction *p1 = getpatt(L, 1, &l1);
  Instruction *p2 = getpatt(L, 2, &l2);
  if (isfail(p1) || issucc(p2))
    lua_pushvalue(L, 1);  /* fail * x == fail; x * true == x */
  else if (isfail(p2) || issucc(p1))
    lua_pushvalue(L, 2);  /* x * fail == fail; true * x == x */
  else if (isany(p1) && isany(p2))
    any(L, p1->i.aux + p2->i.aux, 0, NULL);
  else {
    Instruction *op = newpatt(L, l1 + l2);
    Instruction *p = op + addpatt(L, op, 1);
    addpatt(L, p, 2);
    optimizecaptures(op);
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
callq 0x246779
movq %rax, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x246779
movzbl (%r14), %ecx
cmpl $0xf, %ecx
je 0x246543
movzbl (%rax), %edx
cmpl $0xf, %edx
je 0x246556
cmpl $0x6, %edx
jne 0x24654d
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x24655e
testl %ecx, %ecx
je 0x246570
cmpl $0x6, %ecx
jne 0x24659a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22d798
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb %dl, %dl
jne 0x24659a
cmpb $0x6, 0x8(%r14)
jne 0x24659a
cmpb $0x6, 0x8(%rax)
jne 0x24659a
movzbl 0x1(%r14), %ecx
movzbl 0x1(%rax), %esi
addl %ecx, %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x247473
jmp 0x246563
movslq 0x4(%rsp), %rax
movslq (%rsp), %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2475f9
cltq
leaq (%r14,%rax,8), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2475f9
movq %r14, %rdi
callq 0x2480f7
jmp 0x246563
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: rcapture_l
static int rcapture_l (lua_State *L) {
  switch (lua_type(L, 2)) {
    case LUA_TFUNCTION: return capture_aux(L, Cfunction, 2);
    case LUA_TTABLE: return capture_aux(L, Cquery, 2);
    case LUA_TSTRING: return capture_aux(L, Cstring, 2);
    default: return luaL_argerror(L, 2, "invalid replacement value");
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x22d7b8
cmpl $0x4, %eax
je 0x24660f
cmpl $0x5, %eax
je 0x246605
cmpl $0x6, %eax
jne 0x246628
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x246617
movq %rbx, %rdi
movl $0x8, %esi
jmp 0x246617
movq %rbx, %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x248399
movl $0x1, %eax
popq %rbx
retq
leaq 0x18cc4b(%rip), %rdx    # 0x3d327a
movq %rbx, %rdi
movl $0x2, %esi
popq %rbx
jmp 0x230a08
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: unm_l
static int unm_l (lua_State *L) {
  Instruction *p = getpatt(L, 1, NULL);
  if (isfail(p)) {  /* -false? */
    newpatt(L, 0);  /* true */
    return 1;
  }
  else if (issucc(p)) {  /* -true? */
    Instruction *p1 = newpatt(L, 1);  /* false */
    setinst(p1, IFail, 0);
    return 1;
  }
  else {  /* -A == '' - A */
    lua_pushliteral(L, "");
    lua_insert(L, 1);
    return diff_l(L);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x246779
movzbl (%rax), %eax
cmpl $0x6, %eax
je 0x246666
cmpl $0xf, %eax
jne 0x24667b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x245fcd
jmp 0x2466a1
movl $0x1, %esi
movq %rbx, %rdi
callq 0x245fcd
movl $0xf, (%rax)
jmp 0x2466a1
leaq 0x18c682(%rip), %rsi    # 0x3d2d04
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22deed
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22d562
movq %rbx, %rdi
callq 0x24638f
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: pattand_l
static int pattand_l (lua_State *L) {
  int l1;
  CharsetTag st1;
  Instruction *p1 = getpatt(L, 1, &l1);
  if (isfail(p1) || issucc(p1))
    lua_pushvalue(L, 1);  /* &fail == fail; &true == true */
  else if (tocharset(p1, &st1) == ISCHARSET) {
    Instruction *p = newpatt(L, l1 + 1);
    copypatt(p, p1, l1); p += l1;
    setinstaux(p, IBack, 0, 1);
  }
  else {  /* Choice L1; p1; BackCommit L2; L1: Fail; L2: */
    Instruction *p = newpatt(L, 1 + l1 + 2);
    setinst(p++, IChoice, 1 + l1 + 1);
    p += addpatt(L, p, 1);
    setinst(p++, IBackCommit, 2);
    setinst(p, IFail, 0);
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x246779
movq %rax, %r14
movzbl (%rax), %eax
cmpl $0xf, %eax
je 0x2466cf
cmpl $0x6, %eax
jne 0x2466e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22d798
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x246ec3
movslq (%rsp), %rsi
cmpl $0x1, %eax
jne 0x24672d
incq %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %rbx
movslq (%rsp), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x17660
movslq (%rsp), %rax
movl $0x104, (%rbx,%rax,8)   # imm = 0x104
jmp 0x2466dc
addl $0x3, %esi
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r14
leaq 0x8(%rax), %rsi
movl (%rsp), %eax
movw $0x7, (%r14)
addl $0x2, %eax
movw %ax, 0x2(%r14)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2475f9
cltq
movl $0x2000d, 0x8(%r14,%rax,8) # imm = 0x2000D
movl $0xf, 0x10(%r14,%rax,8)
jmp 0x2466dc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: tocharset
static enum charsetanswer tocharset (Instruction *p, CharsetTag *c) {
  if (isfixcheck(p)) {
    fillcharset(p, c->cs);
    if ((p + sizei(p))->i.code == IEnd && op_step(p) == 1)
      c->tag = ISCHARSET;
    else
      c->tag = VALIDSTARTS;
  }
  else
    c->tag = NOINFO;
  return c->tag;
}

// Assembly:
movzbl (%rdi), %ecx
leaq -0x3(%rcx), %rdx
xorl %eax, %eax
cmpq $0x15, %rdx
jb 0x246f77
cmpw $0x0, 0x2(%rdi)
jne 0x246f77
leaq 0x4(%rsi), %rax
cmpl $0x2, %ecx
je 0x246f14
cmpl $0x1, %ecx
jne 0x246f28
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, (%rax)
movzbl 0x1(%rdi), %edx
movl %edx, %ecx
andb $0x7, %cl
movb $0x1, %r8b
shlb %cl, %r8b
shrl $0x3, %edx
orb %r8b, (%rax,%rdx)
jmp 0x246f35
xorl %ecx, %ecx
movb 0x8(%rdi,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq $0x20, %rcx
jne 0x246f16
jmp 0x246f35
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, (%rax)
movb (%rdi), %cl
movzbl %cl, %edx
movl $0x5, %eax
leal -0x2(%rdx), %r8d
cmpl $0x2, %r8d
jb 0x246f5d
cmpl $0x11, %edx
jne 0x246f58
movzbl 0x1(%rdi), %eax
addq $0x2, %rax
jmp 0x246f5d
movl $0x1, %eax
cmpb $0x6, (%rdi,%rax,8)
jne 0x246f72
movl $0x1, %eax
testb %cl, %cl
jne 0x246f77
cmpb $0x1, 0x1(%rdi)
je 0x246f77
movl $0x2, %eax
movl %eax, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: any
static Instruction *any (lua_State *L, int n, int extra, int *offsetp) {
  int offset = offsetp ? *offsetp : 0;
  Instruction *p = newpatt(L, (n - 1)/UCHAR_MAX + extra + 1);
  Instruction *p1 = p + offset;
  for (; n > UCHAR_MAX; n -= UCHAR_MAX)
    setinstaux(p1++, IAny, 0, UCHAR_MAX);
  setinstaux(p1++, IAny, 0, n);
  if (offsetp) *offsetp = p1 - p;
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %esi, %r14d
testq %rcx, %rcx
je 0x247488
movslq (%rbx), %r15
jmp 0x24748b
xorl %r15d, %r15d
leal -0x1(%r14), %eax
cltq
imulq $-0x7f7f7f7f, %rax, %rax # imm = 0x80808081
shrq $0x20, %rax
addl %r14d, %eax
decl %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x7, %eax
addl %ecx, %eax
leal (%rdx,%rax), %esi
incl %esi
callq 0x245fcd
leaq (%rax,%r15,8), %rcx
cmpl $0x100, %r14d           # imm = 0x100
jl 0x2474de
movl %r14d, %edx
movl $0xff00, (%rcx)         # imm = 0xFF00
addq $0x8, %rcx
leal -0xff(%rdx), %r14d
cmpl $0x1fe, %edx            # imm = 0x1FE
jg 0x2474c2
movb $0x0, (%rcx)
movw $0x0, 0x2(%rcx)
movb %r14b, 0x1(%rcx)
testq %rbx, %rbx
je 0x2474fd
subq %rax, %rcx
addq $0x8, %rcx
shrq $0x3, %rcx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: value2fenv
static int value2fenv (lua_State *L, int vidx) {
  lua_createtable(L, 1, 0);
  lua_pushvalue(L, vidx);
  lua_rawseti(L, -2, 1);
  lua_setfenv(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %esi
xorl %edx, %edx
callq 0x22e8fc
movq %r14, %rdi
movl %ebx, %esi
callq 0x22d798
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x22edd2
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22ef48
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: testpattern
static int testpattern (lua_State *L, int idx) {
  if (lua_touserdata(L, idx)) {  /* value is a userdata? */
    if (lua_getmetatable(L, idx)) {  /* does it have a metatable? */
      luaL_getmetatable(L, PATTERN_T);
      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
        lua_pop(L, 2);  /* remove both metatables */
        return 1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x22de0e
xorl %ebx, %ebx
testq %rax, %rax
je 0x2475a7
movq %r14, %rdi
movl %ebp, %esi
callq 0x22e9d3
testl %eax, %eax
je 0x2475a7
leaq 0x18b841(%rip), %rdx    # 0x3d2db3
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e6f4
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x22d8cb
testl %eax, %eax
je 0x2475a7
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22d42e
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: val2str
static const char *val2str (lua_State *L, int idx) {
  const char *k = lua_tostring(L, idx);
  if (k != NULL)
    return lua_pushfstring(L, "rule '%s'", k);
  else
    return lua_pushfstring(L, "rule <a %s>", luaL_typename(L, idx));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %edx, %edx
callq 0x22db9e
testq %rax, %rax
je 0x2475cb
leaq 0x18b903(%rip), %rsi    # 0x3d2ecc
jmp 0x2475e6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22d7b8
movq %rbx, %rdi
movl %eax, %esi
callq 0x22d7d3
leaq 0x18b8f0(%rip), %rsi    # 0x3d2ed6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22e3dc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: addpatt
static int addpatt (lua_State *L, Instruction *p, int p1idx) {
  Instruction *p1 = (Instruction *)lua_touserdata(L, p1idx);
  int sz = pattsize(L, p1idx);
  int corr = jointable(L, p1idx);
  copypatt(p, p1, sz + 1);
  if (corr != 0) {
    Instruction *px;
    for (px = p; px < p + sz; px += sizei(px)) {
      if (isfenvoff(px) && px->i.offset != 0)
        px->i.offset += corr;
    }
  }
  return sz;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %esi
callq 0x22de0e
movq %rax, %r12
movq %r15, %rdi
movl %r14d, %esi
callq 0x22dc6d
movq %rax, %r13
shrq $0x3, %r13
leal -0x1(%r13), %ebp
movq %r15, %rdi
movl %r14d, %esi
callq 0x2477d6
movl %eax, %r14d
movslq %r13d, %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17660
testl %r14d, %r14d
je 0x2476a7
testl %ebp, %ebp
jle 0x2476a7
movslq %ebp, %rax
leaq (%rbx,%rax,8), %rax
movl $0xbfbff, %ecx          # imm = 0xBFBFF
movl (%rbx), %edx
btq %rdx, %rcx
jb 0x24767a
movzwl 0x2(%rbx), %edx
testw %dx, %dx
je 0x24767a
addl %r14d, %edx
movw %dx, 0x2(%rbx)
movzbl (%rbx), %esi
movl $0x5, %edx
leal -0x2(%rsi), %edi
cmpl $0x2, %edi
jb 0x24769e
cmpl $0x11, %esi
jne 0x247699
movzbl 0x1(%rbx), %edx
addq $0x2, %rdx
jmp 0x24769e
movl $0x1, %edx
leaq (%rbx,%rdx,8), %rbx
cmpq %rax, %rbx
jb 0x247662
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_O1/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 %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22ea28
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebp, %edx
callq 0x22e852
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22db49
movq %rax, %r14
testl %r14d, %r14d
je 0x247712
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22d42e
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %ebp, %edx
callq 0x22e852
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2475ae
leaq 0x18b999(%rip), %rsi    # 0x3d30ce
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x230abd
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %r8b
cmpb $0x6, %r8b
je 0x2477d5
xorl %ecx, %ecx
movl $0xfdc478, %eax         # imm = 0xFDC478
movq %rdi, %rdx
movzbl %r8b, %esi
btq %rsi, %rax
jb 0x24779d
movswl 0x2(%rdx), %r8d
testl %r8d, %r8d
je 0x24779d
addl %ecx, %r8d
movslq %r8d, %rsi
cmpb $0x8, (%rdi,%rsi,8)
jne 0x247794
movswq 0x2(%rdi,%rsi,8), %r9
movslq %r8d, %rsi
addq %r9, %rsi
cmpb $0x8, (%rdi,%rsi,8)
movl %esi, %r8d
je 0x24777d
jmp 0x247797
movl %r8d, %esi
subl %ecx, %esi
movw %si, 0x2(%rdx)
movzbl (%rdx), %r8d
movl $0x5, %esi
leal -0x2(%r8), %r9d
cmpl $0x2, %r9d
jb 0x2477c4
cmpl $0x11, %r8d
jne 0x2477bf
movzbl 0x1(%rdx), %esi
addl $0x2, %esi
jmp 0x2477c4
movl $0x1, %esi
addl %ecx, %esi
leaq (%rdi,%rsi,8), %rdx
movb (%rdx), %r8b
movl %esi, %ecx
cmpb $0x6, %r8b
jne 0x24775d
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x22ea28
movq %rbx, %rdi
callq 0x24791c
movl %eax, %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ea28
testl %r14d, %r14d
je 0x24781a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x22d95d
testl %eax, %eax
je 0x247837
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22d42e
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x24791c
testl %eax, %eax
je 0x2478fd
movl %eax, %r15d
leal (%r15,%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22e8fc
testl %r15d, %r15d
jle 0x24789c
movl %r15d, %r13d
negl %r13d
movl $0x1, %r12d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r12d, %edx
callq 0x22e852
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r12d, %edx
callq 0x22edd2
leal (%r12,%r13), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x247869
testl %r14d, %r14d
jle 0x2478de
negl %r14d
movl $0x1, %r12d
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %r12d, %edx
callq 0x22e852
leal (%r15,%r12), %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22edd2
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x2478aa
movq %rbx, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x22ef48
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22d42e
jmp 0x24782a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ef48
jmp 0x247827
// File: /workspace/github_c_makefile_star2_O1/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 0x245fcd
movq %rax, (%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x2477d6
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_O1/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:
movzbl (%rdi), %edx
xorl %eax, %eax
movl $0xfdfff8, %ecx         # imm = 0xFDFFF8
btq %rdx, %rcx
jb 0x247ede
cmpw $0x0, 0x2(%rdi)
je 0x247edf
retq
movl $0x5, %ecx
leal -0x2(%rdx), %esi
cmpl $0x2, %esi
jb 0x247f00
cmpl $0x11, %edx
jne 0x247efb
movzbl 0x1(%rdi), %ecx
addq $0x2, %rcx
jmp 0x247f00
movl $0x1, %ecx
movb (%rdi,%rcx,8), %sil
cmpb $0x6, %sil
je 0x247f4d
leaq (%rdi,%rcx,8), %rcx
movl $0x83fef7, %edx         # imm = 0x83FEF7
movzbl %sil, %edi
btq %rdi, %rdx
jb 0x247ede
movl $0x5, %esi
leal -0x2(%rdi), %r8d
cmpl $0x2, %r8d
jb 0x247f40
cmpl $0x11, %edi
jne 0x247f3b
movzbl 0x1(%rcx), %esi
addq $0x2, %rsi
jmp 0x247f40
movl $0x1, %esi
leaq (%rcx,%rsi,8), %rcx
movb (%rcx), %sil
cmpb $0x6, %sil
jne 0x247f13
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x248029
movq %rdi, %rbx
movzbl 0x8(%rdi), %eax
leaq -0x3(%rax), %rcx
cmpq $0x15, %rcx
jb 0x248024
cmpw $0x0, 0xa(%rbx)
jne 0x248024
movl $0x5, %ebp
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jb 0x247fd5
cmpl $0x11, %eax
jne 0x247fd0
movzbl 0x9(%rbx), %ebp
addl $0x2, %ebp
jmp 0x247fd5
movl $0x1, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x248067
movzbl (%rbx), %eax
leaq -0x3(%rax), %rcx
cmpq $0x15, %rcx
jb 0x248048
cmpw $0x0, 0x2(%rbx)
jne 0x248048
movl %ebp, %r14d
cmpb $0x7, (%rbx,%r14,8)
jne 0x248048
movb $0x1, %cl
testb %al, %al
jne 0x24800b
movb 0x1(%rbx), %cl
movb %cl, 0x1(%rbx,%r14,8)
movswl 0x2(%rbx,%r14,8), %esi
movq %rbx, %rdi
callq 0x247f53
subw %bp, 0x2(%rbx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18b0fa(%rip), %rdi    # 0x3d312a
leaq 0x18adcb(%rip), %rsi    # 0x3d2e02
leaq 0x18b101(%rip), %rcx    # 0x3d313f
movl $0x398, %edx            # imm = 0x398
callq 0x174d0
leaq 0x18b113(%rip), %rdi    # 0x3d3162
leaq 0x18adac(%rip), %rsi    # 0x3d2e02
leaq 0x18b0e2(%rip), %rcx    # 0x3d313f
movl $0x39c, %edx            # imm = 0x39C
callq 0x174d0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: rotate
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:
cmpl $0x2, %edx
jl 0x248095
leal -0x1(%rdx), %eax
decq %rax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %r8
movq 0x8(%rdi,%rax,8), %r9
movq %r9, (%rdi,%rcx,8)
movq %r8, 0x8(%rdi,%rax,8)
incq %rcx
leaq -0x1(%rax), %r8
cmpq %rax, %rcx
movq %r8, %rax
jl 0x248074
movl %esi, %ecx
subl %edx, %ecx
jle 0x2480ca
movslq %edx, %rax
leaq (%rdi,%rax,8), %rax
movl %ecx, %ecx
decq %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %r8
movq 0x8(%rax,%rcx,8), %r9
movq %r9, (%rax,%rdx,8)
movq %r8, 0x8(%rax,%rcx,8)
incq %rdx
leaq -0x1(%rcx), %r8
cmpq %rcx, %rdx
movq %r8, %rcx
jl 0x2480a9
testl %esi, %esi
jle 0x2480f6
movl %esi, %eax
decq %rax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rdx
movq 0x8(%rdi,%rax,8), %rsi
movq %rsi, (%rdi,%rcx,8)
movq %rdx, 0x8(%rdi,%rax,8)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x2480d5
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movzbl (%rdi), %r9d
leaq -0x3(%r9), %rcx
xorl %eax, %eax
movl $0x0, %r8d
cmpq $0x15, %rcx
jb 0x248395
movl $0xf, %ecx
subl %esi, %ecx
xorl %esi, %esi
movq %rdi, %r10
xorl %r8d, %r8d
movl %r8d, %r11d
cmpw $0x0, 0x2(%r10)
jne 0x24838c
movl $0x1, %r8d
testb %r9b, %r9b
jne 0x24833d
movzbl 0x1(%r10), %r8d
addl %r11d, %r8d
cmpl %ecx, %r8d
cmovgl %r11d, %r8d
jg 0x248393
movzbl %r9b, %r9d
movl $0x5, %eax
leal -0x2(%r9), %r11d
cmpl $0x2, %r11d
jb 0x248371
cmpl $0x11, %r9d
jne 0x24836c
movzbl 0x1(%r10), %eax
addl $0x2, %eax
jmp 0x248371
movl $0x1, %eax
addl %esi, %eax
leaq (%rdi,%rax,8), %r10
movzbl (%r10), %r9d
movq %r9, %r11
addq $-0x3, %r11
movl %eax, %esi
cmpq $0x14, %r11
ja 0x248322
jmp 0x248395
movl %esi, %eax
movl %r11d, %r8d
jmp 0x248395
movl %esi, %eax
movl %r8d, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x246779
movq %rsp, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2482f9
movslq (%r15), %rsi
cmpl %esi, %eax
jne 0x2483ef
incq %rsi
movq %r14, %rdi
callq 0x245fcd
movq %rax, %r15
testl %ebp, %ebp
je 0x248414
movq %r14, %rdi
movl %ebp, %esi
callq 0x247503
movw $0x1, %bp
jmp 0x248416
addl $0x2, %esi
movslq %esi, %rsi
movq %r14, %rdi
callq 0x245fcd
movq %rax, %r15
testl %ebp, %ebp
je 0x24844a
movq %r14, %rdi
movl %ebp, %esi
callq 0x247503
movw $0x1, %ax
jmp 0x24844c
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2475f9
movl (%rsp), %ecx
shll $0x4, %ecx
orl %ebx, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jge 0x248493
cltq
movb $0x12, (%r15,%rax,8)
movw %bp, 0x2(%r15,%rax,8)
movb %cl, 0x1(%r15,%rax,8)
jmp 0x248488
xorl %eax, %eax
cmpl $0x100, %ebx            # imm = 0x100
jge 0x248493
movq %r15, %rsi
addq $0x8, %rsi
movb $0x15, (%r15)
movw %ax, 0x2(%r15)
movb %bl, 0x1(%r15)
movq %r14, %rdi
movl $0x1, %edx
callq 0x2475f9
cltq
movl $0x16, 0x8(%r15,%rax,8)
movq %r15, %rdi
callq 0x2480f7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18a95a(%rip), %rdi    # 0x3d2df4
leaq 0x18a961(%rip), %rsi    # 0x3d2e02
leaq 0x18a97a(%rip), %rcx    # 0x3d2e22
movl $0x3fb, %edx            # imm = 0x3FB
callq 0x174d0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x230fba
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22d42e
leaq 0x18961e(%rip), %rdx    # 0x3d2dc0
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22ec93
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x246779
movq %rax, %r15
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x230fba
movq %rax, %r14
cmpl $0x100, %r14d           # imm = 0x100
jl 0x249803
leaq 0x189f1d(%rip), %rdx    # 0x3d3713
movq %rbx, %rdi
movl $0x2, %esi
callq 0x230a08
movq %r15, %rax
movzbl (%rax), %ecx
cmpl $0x5, %ecx
jg 0x24981d
movl $0x5, %edx
addl $-0x2, %ecx
cmpl $0x2, %ecx
jb 0x24983b
jmp 0x249836
cmpl $0x11, %ecx
jne 0x24982c
movzbl 0x1(%rax), %edx
addq $0x2, %rdx
jmp 0x24983b
cmpl $0x6, %ecx
je 0x249852
cmpl $0xa, %ecx
je 0x249841
movl $0x1, %edx
leaq (%rax,%rdx,8), %rax
jmp 0x249806
leaq 0x189ee6(%rip), %rsi    # 0x3d372e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x230abd
movzbl (%r15), %eax
cmpl $0xf, %eax
je 0x249860
cmpl $0x6, %eax
jne 0x249872
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22d798
jmp 0x24991e
cmpl $0x1, %r14d
jne 0x2498b7
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x246ec3
cmpl $0x1, %eax
jne 0x2498b7
movslq 0x8(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x245fcd
movl $0x104, (%rax)          # imm = 0x104
leaq 0x8(%rax), %rdi
movslq 0x8(%rsp), %rdx
shlq $0x3, %rdx
movq %r15, %rsi
callq 0x17660
jmp 0x24991e
movslq 0x8(%rsp), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r15
movl 0x8(%rsp), %eax
addl $0x3, %eax
movw $0x7, (%r15)
movw %ax, 0x2(%r15)
cmpl $0x100, %r14d           # imm = 0x100
jge 0x24992d
movq %r15, %rsi
addq $0x10, %rsi
movb $0x4, 0x8(%r15)
movw $0x0, 0xa(%r15)
movb %r14b, 0x9(%r15)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2475f9
cltq
movl $0x2000d, 0x10(%r15,%rax,8) # imm = 0x2000D
movl $0xf, 0x18(%r15,%rax,8)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1894c0(%rip), %rdi    # 0x3d2df4
leaq 0x1894c7(%rip), %rsi    # 0x3d2e02
leaq 0x1894e0(%rip), %rcx    # 0x3d2e22
movl $0x3fb, %edx            # imm = 0x3FB
callq 0x174d0
// File: /workspace/github_c_makefile_star2_O1/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 0x22d421
movl %eax, %r14d
leal 0x2(%r14), %eax
cmpl $0x2, %r14d
cmovll %r14d, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x22e8fc
cmpl $0x2, %r14d
jl 0x2499da
movl $0xd15, (%r15)          # imm = 0xD15
addq $0x8, %r15
testl %r14d, %r14d
movq %r14, (%rsp)
jle 0x249a58
movl %r14d, %ebp
negl %ebp
movl $0x1, %r12d
movl $0x1, %r13d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x22d7b8
movb $0x14, (%r15)
testl %eax, %eax
je 0x249a35
movw %r13w, 0x2(%r15)
movb $0x2, 0x1(%r15)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x22d798
leal 0x1(%r13), %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r13d, %edx
callq 0x22edd2
movl %r14d, %r13d
jmp 0x249a41
movw $0x0, 0x2(%r15)
movb $0x2, 0x1(%r15)
addq $0x8, %r15
leal (%r12,%rbp), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x2499f4
cmpl $0x2, (%rsp)
jl 0x249a65
movl $0x16, (%r15)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ef48
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x245fcd
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x247503
movl $0x10314, (%r14)        # imm = 0x10314
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x230f7b
movq %rax, %rbx
movl $0x1, %esi
movq %r14, %rdi
callq 0x245fcd
movq %rax, %r15
movl %ebx, %eax
decl %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jb 0x249b5e
leaq 0x189c0d(%rip), %rdx    # 0x3d375e
movq %r14, %rdi
movl $0x1, %esi
callq 0x230a08
movw $0x413, (%r15)          # imm = 0x413
movw %bx, 0x2(%r15)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x246779
movslq (%r14), %rsi
addq $0x2, %rsi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x230e68
leaq 0x8(%r14), %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x247503
movl $0x10c15, (%r14)        # imm = 0x10C15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2475f9
cltq
movl $0x17, 0x8(%r14,%rax,8)
movq %r14, %rdi
callq 0x2480f7
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22d421
movl %eax, %ebp
movl $0x5, %esi
movq %rbx, %rdi
callq 0x245fcd
movb $0x2, (%rax)
movw $0x0, 0x2(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
testl %ebp, %ebp
jle 0x249cfb
movq %rax, %r14
addq $0x8, %r14
movl $0x1, %r12d
movq %rsp, %r15
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x230d0f
movq %rax, %r13
cmpq $0x2, (%rsp)
je 0x249cc0
movq %rbx, %rdi
movl %r12d, %esi
leaq 0x189aba(%rip), %rdx    # 0x3d3775
callq 0x230a08
movzbl (%r13), %eax
cmpb 0x1(%r13), %al
ja 0x249cee
movl %eax, %ecx
andb $0x7, %cl
movl $0x1, %edx
shll %cl, %edx
movl %eax, %ecx
shrl $0x3, %ecx
orb %dl, (%r14,%rcx)
leal 0x1(%rax), %ecx
movzbl 0x1(%r13), %edx
cmpl %edx, %eax
movl %ecx, %eax
jb 0x249ccb
leal 0x1(%r12), %eax
cmpl %ebp, %r12d
movl %eax, %r12d
jne 0x249c96
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x230d0f
cmpq $0x1, (%r15)
jne 0x249d44
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x246779
jmp 0x249d94
movq %rax, %rbx
movl $0x5, %esi
movq %r14, %rdi
callq 0x245fcd
movb $0x2, (%rax)
movw $0x0, 0x2(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
subq $0x1, 0x8(%rsp)
jb 0x249d94
addq $0x8, %rax
movzbl (%rbx), %edx
movl %edx, %ecx
andb $0x7, %cl
movb $0x1, %sil
shlb %cl, %sil
shrl $0x3, %edx
orb %sil, (%rax,%rdx)
incq %rbx
subq $0x1, 0x8(%rsp)
jae 0x249d74
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x22d7b8
testl %eax, %eax
jg 0x249dcc
leaq 0x1899d5(%rip), %rdx    # 0x3d3794
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230a08
movl $0x1, %esi
movq %rbx, %rdi
callq 0x245fcd
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x247503
movl $0x1000a, (%r14)        # imm = 0x1000A
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x247548
testl %eax, %eax
je 0x249e25
leaq 0x10ba01(%rip), %rsi    # 0x355817
movl $0x7, %edx
movq %rbx, %rdi
callq 0x22deed
jmp 0x249e2d
movq %rbx, %rdi
callq 0x22deaa
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22de0e
movq %rax, %r15
movq %rbx, (%rsp)
movq (%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbx
leaq 0x188f35(%rip), %rdx    # 0x3d2dc0
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e6f4
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22db49
movq %rax, %r12
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
cmpl %r12d, %ebx
jl 0x249ecb
leaq 0x1890e2(%rip), %rsi    # 0x3d2fa3
movq %r14, %rdi
xorl %eax, %eax
callq 0x230abd
leal (%rbx,%rbx), %eax
cmpl %r12d, %eax
cmovll %eax, %r12d
movslq %r12d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x22f9f1
movq %rax, %r13
movslq %ebx, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rbx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x17660
movq %r14, %rdi
movl %ebp, %esi
callq 0x22d59f
addq %r13, %r12
movq (%rsp), %rax
movq %r12, (%rax)
addq %rbx, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x249f5d
leaq 0x18849e(%rip), %rsi    # 0x3d23f1
movq %r14, %rdi
xorl %eax, %eax
callq 0x230abd
leal (%r12,%r12), %eax
movslq %eax, %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x22f9f1
movq %rax, %r13
movslq %r12d, %rdx
shlq $0x4, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x17660
addl $0x2, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x22d59f
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x249fd2
movq 0x10(%rbx), %rdi
movq (%r15), %rsi
decl %edx
callq 0x22deed
movl $0x1, %ebp
jmp 0x24a021
movl %esi, %r14d
movq (%rbx), %rax
cmpb $0x0, 0xa(%rax)
je 0x249ff5
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x24a02e
addl %eax, %ebp
movq (%rbx), %rax
cmpb $0x0, 0xa(%rax)
jne 0x249fe0
jmp 0x249ff7
xorl %ebp, %ebp
testl %r14d, %r14d
setne %cl
testl %ebp, %ebp
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x24a01d
movq 0x10(%rbx), %rdi
movq (%r15), %rsi
movq (%rax), %rdx
subq %rsi, %rdx
callq 0x22deed
incl %ebp
addq $0x10, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq