LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_lock
static int _file_lock (lua_State *L, FILE *fh, const char *mode, const long start, long len, const char *funcname) {
	int code;
#ifdef _WIN32
	/* lkmode valid values are:
	   LK_LOCK    Locks the specified bytes. If the bytes cannot be locked, the program immediately tries again after 1 second. If, after 10 attempts, the bytes cannot be locked, the constant returns an error.
	   LK_NBLCK   Locks the specified bytes. If the bytes cannot be locked, the constant returns an error.
	   LK_NBRLCK  Same as _LK_NBLCK.
	   LK_RLCK    Same as _LK_LOCK.
	   LK_UNLCK   Unlocks the specified bytes, which must have been previously locked.

	   Regions should be locked only briefly and should be unlocked before closing a file or exiting the program.

	   http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__locking.asp
	*/
	int lkmode;
	switch (*mode) {
		case 'r': lkmode = LK_NBLCK; break;
		case 'w': lkmode = LK_NBLCK; break;
		case 'u': lkmode = LK_UNLCK; break;
		default : return luaL_error (L, "%s: invalid mode", funcname);
	}
	if (!len) {
		fseek (fh, 0L, SEEK_END);
		len = ftell (fh);
	}
	fseek (fh, start, SEEK_SET);
#ifdef __BORLANDC__
	code = locking (fileno(fh), lkmode, len);
#else
	code = _locking (fileno(fh), lkmode, len);
#endif
#else
	struct flock f;
	switch (*mode) {
		case 'w': f.l_type = F_WRLCK; break;
		case 'r': f.l_type = F_RDLCK; break;
		case 'u': f.l_type = F_UNLCK; break;
		default : return luaL_error (L, "%s: invalid mode", funcname);
	}
	f.l_whence = SEEK_SET;
	f.l_start = (off_t)start;
	f.l_len = (off_t)len;
	code = fcntl (fileno(fh), F_SETLK, &f);
#endif
	return (code != -1);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movq 0x48(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x72, %eax
je 0x35d8c4
jmp 0x35d8a5
movl 0x4(%rsp), %eax
subl $0x75, %eax
je 0x35d8cd
jmp 0x35d8b0
movl 0x4(%rsp), %eax
subl $0x77, %eax
jne 0x35d8d6
jmp 0x35d8bb
movw $0x1, 0x8(%rsp)
jmp 0x35d8f4
movw $0x0, 0x8(%rsp)
jmp 0x35d8f4
movw $0x2, 0x8(%rsp)
jmp 0x35d8f4
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x23efc1(%rip), %rsi    # 0x59c8a8
movb $0x0, %al
callq 0x33a320
movl %eax, 0x64(%rsp)
jmp 0x35d941
movw $0x0, 0xa(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x197a0
movl %eax, %edi
movl $0x6, %esi
leaq 0x8(%rsp), %rdx
movb $0x0, %al
callq 0x19bc0
movl %eax, 0x2c(%rsp)
cmpl $-0x1, 0x2c(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: luaopen_lpeg
int luaopen_lpeg (lua_State *L) {
  lua_pushcfunction(L, (lua_CFunction)&l_newpf);  /* new-pattern function */
  lua_setfield(L, LUA_REGISTRYINDEX, KEYNEWPATT);  /* register it */
  luaL_newmetatable(L, PATTERN_T);
  lua_pushnumber(L, MAXBACK);
  lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
  luaL_register(L, NULL, metapattreg);
  luaL_register(L, "lpeg", pattreg);
  lua_pushliteral(L, "__index");
  lua_pushvalue(L, -2);
  lua_settable(L, -4);
  return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0xc0(%rip), %rsi        # 0x35da60
xorl %edx, %edx
callq 0x335ef0
movq (%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x23f1e9(%rip), %rdx    # 0x59cba0
callq 0x336d90
movq (%rsp), %rdi
leaq 0x23f1e4(%rip), %rsi    # 0x59cbab
callq 0x33a700
movq (%rsp), %rdi
movsd 0x1bce60(%rip), %xmm0   # 0x51a838
callq 0x3354a0
movq (%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x23f1cb(%rip), %rdx    # 0x59cbb8
callq 0x336d90
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x2e157f(%rip), %rdx    # 0x63ef80
callq 0x33ac00
movq (%rsp), %rdi
leaq 0x1b87a3(%rip), %rsi    # 0x5161b4
leaq 0x2e15e8(%rip), %rdx    # 0x63f000
callq 0x33ac00
movq (%rsp), %rdi
leaq 0x2089ac(%rip), %rsi    # 0x5663d4
movl $0x7, %edx
callq 0x335540
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x334560
movq (%rsp), %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x336ae0
movl $0x1, %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: l_newpf
static void l_newpf (lua_State *L, PattFunc f, const void *ud, size_t l) {
  int n = instsize(l) + 1;
  Instruction *p = newpatt(L, n);
  if (n > MAXAUX) luaL_error(L, "pattern data too long");
  p[0].i.code = IFunc;
  p[0].i.aux = n - 2;
  p[0].i.offset = 0;
  p[1].f = f;
  memcpy(p[2].buff, ud, l);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
subq $0x1, %rax
shrq $0x3, %rax
addq $0x1, %rax
addq $0x1, %rax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x35db20
movq %rax, 0x8(%rsp)
cmpl $0xff, 0x14(%rsp)
jle 0x35dac6
movq 0x30(%rsp), %rdi
leaq 0x23f107(%rip), %rsi    # 0x59cbc6
movb $0x0, %al
callq 0x33a320
movq 0x8(%rsp), %rax
movb $0x11, (%rax)
movl 0x14(%rsp), %eax
subl $0x2, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x2(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x19610
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: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x7ff4, 0x8(%rsp)      # imm = 0x7FF4
jb 0x35db4c
movq 0x10(%rsp), %rdi
leaq 0x23f097(%rip), %rsi    # 0x59cbdc
movb $0x0, %al
callq 0x33a320
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x338720
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x23f033(%rip), %rdx    # 0x59cbab
callq 0x336410
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x3371c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x6, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
movq (%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: setinstaux
static void setinstaux (Instruction *i, Opcode op, int offset, int aux) {
  assert(aux <= MAXAUX);
  i->i.code = op;
  i->i.offset = offset;
  i->i.aux = aux;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
cmpl $0xff, 0x4(%rsp)
jg 0x35dbe1
jmp 0x35dc00
leaq 0x23f004(%rip), %rdi    # 0x59cbec
leaq 0x23f00b(%rip), %rsi    # 0x59cbfa
movl $0x3fb, %edx            # imm = 0x3FB
leaq 0x23f01f(%rip), %rcx    # 0x59cc1a
callq 0x19490
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movl 0x8(%rsp), %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0x2(%rax)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
leaq 0x4c(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movl $0x2, %esi
leaq 0x48(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xf, %eax
jne 0x35dc91
movq 0x50(%rsp), %rdi
movl $0x2, %esi
callq 0x334560
jmp 0x35dcee
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xf, %eax
je 0x35dcab
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0x35dcbc
movq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x334560
jmp 0x35dcec
movq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x35e840
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x4c(%rsp), %edx
movl 0x48(%rsp), %ecx
leaq 0x44(%rsp), %r8
leaq 0xc(%rsp), %r9
callq 0x35e920
jmp 0x35dcee
movl $0x1, %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: star_l
static int star_l (lua_State *L) {
  int l1;
  int n = luaL_checkint(L, 2);
  Instruction *p1 = getpatt(L, 1, &l1);
  if (n >= 0) {
    CharsetTag st;
    Instruction *op;
    if (tocharset(p1, &st) == ISCHARSET)
      return repeatcharset(L, st.cs, l1, n);
    if (isheadfail(p1))
      op = repeatheadfail(L, l1, n);
    else
      op = repeats(L, p1, l1, n);
    optimizecaptures(op);
    optimizejumps(op);
  }
  else {
    if (isheadfail(p1))
      optionalheadfail(L, l1, -n);
    else
      optionals(L, l1, -n);
  }
  return 1;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x33aa10
movl %eax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x44(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x40(%rsp)
jl 0x35ddd2
movq 0x38(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x35e840
cmpl $0x1, %eax
jne 0x35dd78
movq 0x48(%rsp), %rdi
leaq 0x14(%rsp), %rsi
addq $0x4, %rsi
movl 0x44(%rsp), %edx
movl 0x40(%rsp), %ecx
callq 0x360da0
movl %eax, 0x54(%rsp)
jmp 0x35de15
movq 0x38(%rsp), %rdi
callq 0x360920
cmpl $0x0, %eax
je 0x35dda0
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
callq 0x360e80
movq %rax, 0x8(%rsp)
jmp 0x35ddbc
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x44(%rsp), %edx
movl 0x40(%rsp), %ecx
callq 0x360f70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3610b0
movq 0x8(%rsp), %rdi
callq 0x35f800
jmp 0x35de0d
movq 0x38(%rsp), %rdi
callq 0x360920
cmpl $0x0, %eax
je 0x35ddf7
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
xorl %edx, %edx
subl 0x40(%rsp), %edx
callq 0x361440
jmp 0x35de0b
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
xorl %edx, %edx
subl 0x40(%rsp), %edx
callq 0x3614f0
jmp 0x35de0d
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x2c(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xf, %eax
je 0x35e0f5
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0x35e109
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x334560
jmp 0x35e201
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xf, %eax
je 0x35e123
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0x35e137
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x334560
jmp 0x35e1ff
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x35e193
movq 0x20(%rsp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x6, %eax
jne 0x35e193
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x35e193
movq 0x18(%rsp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x6, %eax
jne 0x35e193
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movzbl 0x1(%rax), %esi
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x35ebe0
jmp 0x35e1fd
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
addl 0x28(%rsp), %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x35f350
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x2, %edx
callq 0x35f350
movq 0x10(%rsp), %rdi
callq 0x3610b0
jmp 0x35e1ff
jmp 0x35e201
movl $0x1, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3345d0
movl %eax, %ecx
movl %ecx, 0x4(%rsp)
subl $0x4, %eax
je 0x35e27f
jmp 0x35e235
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0x35e265
jmp 0x35e240
movl 0x4(%rsp), %eax
subl $0x6, %eax
jne 0x35e299
jmp 0x35e24b
movq 0x8(%rsp), %rdi
movl $0x7, %esi
movl $0x2, %edx
callq 0x361770
movl %eax, 0x14(%rsp)
jmp 0x35e2b3
movq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x361770
movl %eax, 0x14(%rsp)
jmp 0x35e2b3
movq 0x8(%rsp), %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x361770
movl %eax, 0x14(%rsp)
jmp 0x35e2b3
movq 0x8(%rsp), %rdi
movl $0x2, %esi
leaq 0x23edc8(%rip), %rdx    # 0x59d072
callq 0x33a1f0
movl %eax, 0x14(%rsp)
movl 0x14(%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: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x35e4f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xf, %eax
jne 0x35e306
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x35db20
movl $0x1, 0x24(%rsp)
jmp 0x35e376
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0x35e344
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x35db20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0xf, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
movl $0x1, 0x24(%rsp)
jmp 0x35e376
movq 0x18(%rsp), %rdi
leaq 0x23f2d8(%rip), %rsi    # 0x59d628
xorl %eax, %eax
movl %eax, %edx
callq 0x335540
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x3341a0
movq 0x18(%rsp), %rdi
callq 0x35de20
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %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: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
leaq 0x3c(%rsp), %rdx
callq 0x35e4f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xf, %eax
je 0x35e3bc
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
jne 0x35e3d0
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x334560
jmp 0x35e4e3
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x35e840
cmpl $0x1, %eax
jne 0x35e448
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movslq 0x3c(%rsp), %rdx
shlq $0x3, %rdx
callq 0x19610
movl 0x3c(%rsp), %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x4, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x35dbc0
jmp 0x35e4e1
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
addl $0x1, %eax
addl $0x2, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movl 0x3c(%rsp), %edx
addl $0x1, %edx
addl $0x1, %edx
movl $0x7, %esi
xorl %ecx, %ecx
callq 0x35dbc0
movq 0x40(%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 $0xd, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x35dbc0
movq (%rsp), %rdi
movl $0xf, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
jmp 0x35e4e3
movl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x23e2d1(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x35e904
movq 0x20(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x35e904
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0x360290
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x35f7b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0x6, %eax
jne 0x35e8f7
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x35e8d6
movq 0x20(%rsp), %rax
movzbl 0x1(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x35e8e1
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x35e8e1
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
jne 0x35e8f7
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
jmp 0x35e902
movq 0x18(%rsp), %rax
movl $0x2, (%rax)
jmp 0x35e90f
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x35ec0b
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x35ec13
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x35ec13
movl 0x4(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl $0xff, %ecx
cltd
idivl %ecx
addl 0x28(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpl $0xff, 0x2c(%rsp)
jle 0x35ec91
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
xorl %edx, %edx
movl $0xff, %ecx
movl %edx, %esi
callq 0x35dbc0
movl 0x2c(%rsp), %eax
subl $0xff, %eax
movl %eax, 0x2c(%rsp)
jmp 0x35ec59
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %ecx
xorl %edx, %edx
movl %edx, %esi
callq 0x35dbc0
cmpq $0x0, 0x20(%rsp)
je 0x35ecd1
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x336790
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x334560
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x337050
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x337320
movl $0x1, %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: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x335300
cmpq $0x0, %rax
je 0x35f290
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x3368d0
cmpl $0x0, %eax
je 0x35f28e
movq 0x8(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x23d956(%rip), %rdx    # 0x59cbab
callq 0x336410
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x334850
cmpl $0x0, %eax
je 0x35f28c
movq 0x8(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x333ed0
movl $0x1, 0x14(%rsp)
jmp 0x35f298
jmp 0x35f28e
jmp 0x35f290
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %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: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x35f2fb
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x23d9d7(%rip), %rsi    # 0x59ccc4
movb $0x0, %al
callq 0x335df0
movq %rax, 0x30(%rsp)
jmp 0x35f344
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3345d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x334620
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x23d996(%rip), %rsi    # 0x59ccce
movb $0x0, %al
callq 0x335df0
movq %rax, 0x30(%rsp)
movq 0x30(%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: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x335300
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3350d0
shrq $0x3, %rax
subq $0x1, %rax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x35f8c0
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x19610
cmpl $0x0, 0x10(%rsp)
je 0x35f451
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x14(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x35f44f
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x23d731(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x35f42b
movq 0x8(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x35f42b
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rax
movswl 0x2(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x2(%rax)
jmp 0x35f42d
movq 0x8(%rsp), %rdi
callq 0x35f7b0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x35f3d3
jmp 0x35f451
movl 0x14(%rsp), %eax
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: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3369c0
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x336650
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x336210
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x334e60
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x35f741
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x336650
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x35f2b0
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x23d792(%rip), %rsi    # 0x59cec6
movb $0x0, %al
callq 0x33a320
movl %eax, 0x24(%rsp)
jmp 0x35f758
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x333ed0
movl 0xc(%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: sizei
static int sizei (const Instruction *i) {
  switch((Opcode)i->i.code) {
    case ISet: case ISpan: return CHARSETINSTSIZE;
    case IFunc: return funcinstsize(i);
    default: return 1;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
addl $-0x2, %eax
subl $0x2, %eax
jb 0x35f7d6
jmp 0x35f7cb
movl -0x14(%rsp), %eax
subl $0x11, %eax
je 0x35f7e0
jmp 0x35f7f2
movl $0x5, -0x4(%rsp)
jmp 0x35f7fa
movq -0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
addl $0x2, %eax
movl %eax, -0x4(%rsp)
jmp 0x35f7fa
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0x6, %eax
je 0x35f8b8
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
movl %eax, %ecx
leaq 0x23d2f1(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x35f893
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movswl 0x2(%rax,%rcx,8), %eax
cmpl $0x0, %eax
je 0x35f893
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movswl 0x2(%rax,%rcx,8), %eax
addl %eax, %esi
callq 0x35f770
subl 0xc(%rsp), %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movw %dx, 0x2(%rax,%rcx,8)
jmp 0x35f895
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x35f7b0
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x35f811
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: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x3369c0
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x35fa50
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x3369c0
cmpl $0x0, 0xc(%rsp)
je 0x35f91d
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3349b0
cmpl $0x0, %eax
je 0x35f939
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x333ed0
movl $0x0, 0x24(%rsp)
jmp 0x35fa46
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x35fa50
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x35f97e
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x337320
movl $0x0, 0x24(%rsp)
jmp 0x35fa46
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
addl 0xc(%rsp), %esi
xorl %edx, %edx
callq 0x336790
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0x35f9d7
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x336650
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x337050
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x35f99a
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jg 0x35fa20
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x336650
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %edx
addl 0x8(%rsp), %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x337050
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x35f9df
movq 0x18(%rsp), %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x337320
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x333ed0
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %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: fillcharset
static void fillcharset (Instruction *p, Charset cs) {
  switch (p[0].i.code) {
    case ISet: {
      loopset(i, cs[i] = p[1].buff[i]);
      break;
    }
    case IChar: {
      loopset(i, cs[i] = 0);
      setchar(cs, p[0].i.aux);
      break;
    }
    default: {  /* any char may start unhandled instructions */
      loopset(i, cs[i] = 0xff);
      break;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rsp)
subl $0x1, %eax
je 0x3602f8
jmp 0x3602ad
movl -0x20(%rsp), %eax
subl $0x2, %eax
jne 0x360354
jmp 0x3602bc
movl $0x0, -0x14(%rsp)
cmpl $0x20, -0x14(%rsp)
jge 0x3602f3
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movb 0x8(%rax,%rcx), %dl
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3602c4
jmp 0x360380
movl $0x0, -0x18(%rsp)
cmpl $0x20, -0x18(%rsp)
jge 0x360322
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x360300
movq -0x8(%rsp), %rax
movzbl 0x1(%rax), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x360380
movl $0x0, -0x1c(%rsp)
cmpl $0x20, -0x1c(%rsp)
jge 0x36037e
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movb $-0x1, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x36035c
jmp 0x360380
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: firstpart
static int firstpart (Instruction *p, int l) {
  if (istest(p)) {
    int e = p[0].i.offset - 1;
    if ((p[e].i.code == IJmp || p[e].i.code == ICommit) &&
        e + p[e].i.offset == l)
      return e + 1;
  }
  else if (p[0].i.code == IChoice) {
    int e = p[0].i.offset - 1;
    if (p[e].i.code == ICommit && e + p[e].i.offset == l)
      return e + 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x23c786(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x360423
movq -0x10(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x360423
movq -0x10(%rsp), %rax
movswl 0x2(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0x8, %eax
je 0x3603f9
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0xb, %eax
jne 0x360421
movl -0x18(%rsp), %eax
movq -0x10(%rsp), %rcx
movslq -0x18(%rsp), %rdx
movswl 0x2(%rcx,%rdx,8), %ecx
addl %ecx, %eax
cmpl -0x14(%rsp), %eax
jne 0x360421
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x360487
jmp 0x36047f
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x7, %eax
jne 0x36047d
movq -0x10(%rsp), %rax
movswl 0x2(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0xb, %eax
jne 0x36047b
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movswl 0x2(%rcx,%rdx,8), %ecx
addl %ecx, %eax
cmpl -0x14(%rsp), %eax
jne 0x36047b
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x360487
jmp 0x36047d
jmp 0x36047f
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: interfere
static int interfere (Instruction *p1, int l1, CharsetTag *st2) {
  if (nofail(p1, l1))  /* p1 cannot fail? */
    return 0;  /* nothing can intefere with it */
  if (st2->tag == NOINFO) return 1;
  assert(p1->i.offset != 0);
  switch (p1->i.code) {
    case IChar: return testchar(st2->cs, p1->i.aux);
    case ISet: return !exclusiveset(st2->cs, (p1 + 1)->buff);
    default: assert(p1->i.code == IAny); return 1;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x360d20
cmpl $0x0, %eax
je 0x360732
movl $0x0, 0x24(%rsp)
jmp 0x36082c
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x360749
movl $0x1, 0x24(%rsp)
jmp 0x36082c
movq 0x18(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x360759
jmp 0x360778
leaq 0x23c827(%rip), %rdi    # 0x59cf87
leaq 0x23c493(%rip), %rsi    # 0x59cbfa
movl $0x5da, %edx            # imm = 0x5DA
leaq 0x23c826(%rip), %rcx    # 0x59cf99
callq 0x19490
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x360796
jmp 0x36078b
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x3607cc
jmp 0x3607f6
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0x4(%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x36082c
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x360bd0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x36082c
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x360805
jmp 0x360824
leaq 0x23c7bd(%rip), %rdi    # 0x59cfc9
leaq 0x23c3e7(%rip), %rsi    # 0x59cbfa
movl $0x5de, %edx            # imm = 0x5DE
leaq 0x23c77a(%rip), %rcx    # 0x59cf99
callq 0x19490
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: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
addl 0xc(%rsp), %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x35f8c0
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %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: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x23c1f6(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x360953
movq 0x8(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x36095d
movl $0x0, 0x14(%rsp)
jmp 0x3609dc
movq 0x8(%rsp), %rdi
callq 0x35f7b0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x6, %eax
je 0x3609d4
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x23c195(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x3609b0
movl $0x0, 0x14(%rsp)
jmp 0x3609dc
jmp 0x3609b2
movq 0x8(%rsp), %rdi
callq 0x35f7b0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x36097d
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %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: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x7, %eax
jne 0x360a88
jmp 0x360aa7
leaq 0x23c493(%rip), %rdi    # 0x59cf22
leaq 0x23c164(%rip), %rsi    # 0x59cbfa
movl $0x398, %edx            # imm = 0x398
leaq 0x23c495(%rip), %rcx    # 0x59cf37
callq 0x19490
movq 0x10(%rsp), %rax
movzbl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x23c077(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x360bcb
movq 0x10(%rsp), %rax
movswl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x360bcb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x35f7b0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
callq 0x360c40
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x23c020(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x360b3e
movq 0x10(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x360b3e
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
cmpl $0x7, %eax
jne 0x360b3e
jmp 0x360b5d
leaq 0x23c415(%rip), %rdi    # 0x59cf5a
leaq 0x23c0ae(%rip), %rsi    # 0x59cbfa
movl $0x39c, %edx            # imm = 0x39C
leaq 0x23c3df(%rip), %rcx    # 0x59cf37
callq 0x19490
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x360b79
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x360b84
movl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x360b84
movl 0x8(%rsp), %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, 0x1(%rax,%rcx,8)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movswl 0x2(%rax,%rcx,8), %esi
callq 0x3609f0
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movswl 0x2(%rax,%rcx,8), %edx
subl %esi, %edx
movw %dx, 0x2(%rax,%rcx,8)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: invert
static void invert (Instruction *p, int e) {
  int i;
  for (i = 0; i < e; i++, e--) {
    Instruction temp = p[i];
    p[i] = p[e];
    p[e] = temp;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x360d15
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rdx
movslq -0xc(%rsp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movq -0x18(%rsp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x360cb1
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: nofail
static int nofail (Instruction *p, int l) {
  int i;
  for (i = 0; i < l; i += sizei(p + i)) {
    if (!isnofail(p + i)) return 0;
  }
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x360d87
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movzbl (%rax,%rcx,8), %eax
movl %eax, %ecx
leaq 0x23bddd(%rip), %rax    # 0x59cb30
movl (%rax,%rcx,4), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x360d68
movl $0x0, 0x14(%rsp)
jmp 0x360d8f
jmp 0x360d6a
movq 0x8(%rsp), %rdi
movslq (%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x35f7b0
addl (%rsp), %eax
movl %eax, (%rsp)
jmp 0x360d34
movl $0x1, 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: repeatcharset
static int repeatcharset (lua_State *L, Charset cs, int l1, int n) {
  /* e; ...; e; span; */
  int i;
  Instruction *p = newpatt(L, n*l1 + CHARSETINSTSIZE);
  for (i = 0; i < n; i++) {
    p += addpatt(L, p, 1);
  }
  setinst(p, ISpan, 0);
  loopset(k, p[1].buff[k] = cs[k]);
  return 1;
}

// 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
imull 0x24(%rsp), %eax
movslq %eax, %rsi
addq $0x5, %rsi
callq 0x35db20
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x360e1e
movq 0x30(%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)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x360ddd
movq 0x10(%rsp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x35dbc0
movl $0x0, 0xc(%rsp)
cmpl $0x20, 0xc(%rsp)
jge 0x360e68
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, 0x8(%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x360e39
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: repeatheadfail
static Instruction *repeatheadfail (lua_State *L, int l1, int n) {
  /* e; ...; e; L2: e'(L1); jump L2; L1: ... */
  int i;
  Instruction *p = newpatt(L, (n + 1)*l1 + 1);
  Instruction *op = p;
  for (i = 0; i < n; i++) {
    p += addpatt(L, p, 1);
  }
  p += addpatt(L, p, 1);
  check2test(p - l1, l1 + 1);
  setinst(p, IJmp, -l1);
  return 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
addl $0x1, %eax
imull 0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x35db20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x360f04
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)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x360ec3
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 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x3609f0
movq 0x8(%rsp), %rdi
xorl %edx, %edx
subl 0x1c(%rsp), %edx
movl $0x8, %esi
xorl %ecx, %ecx
callq 0x35dbc0
movq (%rsp), %rax
addq $0x28, %rsp
retq