LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: luaopen_lfs
int luaopen_lfs (lua_State *L) {
	dir_create_meta (L);
	lock_create_meta (L);
	luaL_register (L, "lfs", fslib);
	set_info (L);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18c87a(%rip), %rsi    # 0x3c922d
callq 0x2270b9
leaq 0x1570a9(%rip), %r14    # 0x393a68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2243ba
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x150a7d(%rip), %rsi    # 0x38d45a
movq %rbx, %rdi
callq 0x2243ba
leaq 0x1b6(%rip), %rsi       # 0x23cba2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2247b8
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18bed2(%rip), %rsi    # 0x3c88dc
movq %rbx, %rdi
callq 0x2243ba
leaq 0x1fb(%rip), %r12       # 0x23cc14
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2247b8
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x160ab1(%rip), %r15    # 0x39d4f8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2243ba
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2247b8
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18c7df(%rip), %rsi    # 0x3c9252
movq %rbx, %rdi
callq 0x2270b9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x1b1(%rip), %r12       # 0x23cc3f
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2247b8
leaq 0x133e40(%rip), %rdx    # 0x3708e2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x224f78
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0x224f78
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2247b8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x224f78
leaq 0x18c897(%rip), %rsi    # 0x3c937a
leaq 0x278c96(%rip), %rdx    # 0x4b5780
movq %rbx, %rdi
callq 0x227465
leaq 0x18c57b(%rip), %rsi    # 0x3c9074
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18c871(%rip), %rsi    # 0x3c937e
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18c571(%rip), %rsi    # 0x3c909f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18c863(%rip), %rsi    # 0x3c93a5
movl $0x8c, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18b8d7(%rip), %rsi    # 0x3c843a
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18c8bb(%rip), %rsi    # 0x3c9432
movl $0x13, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: dir_close
static int dir_close (lua_State *L) {
	dir_data *d = (dir_data *)lua_touserdata (L, 1);
#ifdef _WIN32
	if (!d->closed && d->hFile) {
		_findclose (d->hFile);
		d->closed = 1;
	}
#else
	if (!d->closed && d->dir) {
		closedir (d->dir);
		d->closed = 1;
	}
#endif
	return 0;
}

// Assembly:
pushq %rbx
movl $0x1, %esi
callq 0x224118
cmpl $0x0, (%rax)
jne 0x23cc3b
movq %rax, %rbx
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x23cc3b
callq 0x17c80
movl $0x1, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: lfs_unlock_dir
static int lfs_unlock_dir(lua_State *L) {
  lfs_Lock *lock = luaL_checkudata(L, 1, LOCK_METATABLE);
  if(lock->ln) {
    unlink(lock->ln);
    free(lock->ln);
    lock->ln = NULL;
  }
  return 0;
}

// Assembly:
pushq %rbx
leaq 0x18c60b(%rip), %rdx    # 0x3c9252
movl $0x1, %esi
callq 0x22712c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x23cc70
movq %rax, %rbx
callq 0x17320
movq (%rbx), %rdi
callq 0x17fe8
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: change_dir
static int change_dir (lua_State *L) {
	const char *path = luaL_checkstring(L, 1);
	if (chdir(path)) {
		lua_pushnil (L);
		lua_pushfstring (L,"Unable to change working directory to '%s'\n%s\n",
				path, chdir_error);
		return 2;
	} else {
		lua_pushboolean (L, 1);
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %r14
movq %rax, %rdi
callq 0x17b10
testl %eax, %eax
je 0x23ccd9
movq %rbx, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c615(%rip), %rsi    # 0x3c92d7
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x224708
movl $0x2, %ebp
jmp 0x23cce6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2248a3
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: get_dir
static int get_dir (lua_State *L) {
  char *path;
  if ((path = getcwd(NULL, 0)) == NULL) {
    lua_pushnil(L);
    lua_pushstring(L, getcwd_error);
    return 2;
  }
  else {
    lua_pushstring(L, path);
    free(path);
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x17360
testq %rax, %rax
je 0x23cd1f
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2243ba
movq %r14, %rdi
callq 0x17fe8
movl $0x1, %eax
jmp 0x23cd43
movq %rbx, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2243ba
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: dir_iter_factory
static int dir_iter_factory (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	dir_data *d;
	lua_pushcfunction (L, dir_iter);
	d = (dir_data *) lua_newuserdata (L, sizeof(dir_data));
	d->closed = 0;
#ifdef _WIN32
	d->hFile = 0L;
	luaL_getmetatable (L, DIR_METATABLE);
	lua_setmetatable (L, -2);
	if (strlen(path) > MAX_DIR_LENGTH)
		luaL_error (L, "path too long: %s", path);
	else
		sprintf (d->pattern, "%s/*", path);
#else
	luaL_getmetatable (L, DIR_METATABLE);
	lua_setmetatable (L, -2);
	d->dir = opendir (path);
	if (d->dir == NULL)
		luaL_error (L, "cannot open %s: %s", path, strerror (errno));
#endif
	return 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %r14
leaq -0x1c7(%rip), %rsi      # 0x23cba2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2247b8
movl $0x10, %esi
movq %rbx, %rdi
callq 0x225cfa
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x18c49d(%rip), %rdx    # 0x3c922d
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224a06
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x225186
movq %r14, %rdi
callq 0x17b60
movq %rax, 0x8(%r15)
testq %rax, %rax
jne 0x23cdde
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c538(%rip), %rsi    # 0x3c9306
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x226e43
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_lock
static int file_lock (lua_State *L) {
	FILE *fh = check_file (L, 1, "lock");
	const char *mode = luaL_checkstring (L, 2);
	const long start = luaL_optlong (L, 3, 0);
	long len = luaL_optlong (L, 4, 0);
	if (_file_lock (L, fh, mode, start, len, "lock")) {
		lua_pushboolean (L, 1);
		return 1;
	} else {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x198e33(%rip), %r15    # 0x3d5c31
movq %r15, %rsi
callq 0x23d3dc
movq %rax, %r12
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %r13
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x227333
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x227333
movzbl (%r13), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rcx
movq %rax, %r8
movq %r15, %r9
callq 0x23d42e
testl %eax, %eax
je 0x23ce72
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x2248a3
jmp 0x23ce9a
movq %r14, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18bc1c(%rip), %rsi    # 0x3c8aa9
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x224708
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: make_dir
static int make_dir (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	int fail;
#ifdef _WIN32
	int oldmask = umask (0);
	fail = _mkdir (path);
#else
	mode_t oldmask = umask( (mode_t)0 );
	fail =  mkdir (path, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP |
	                     S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH );
#endif
	if (fail) {
		lua_pushnil (L);
        lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
	umask (oldmask);
	lua_pushboolean (L, 1);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %r15
xorl %edi, %edi
callq 0x17e00
movl %eax, %r14d
movq %r15, %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x17310
testl %eax, %eax
je 0x23cf13
movq %rbx, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18bbaa(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x224708
movl $0x2, %ebp
jmp 0x23cf28
movl %r14d, %edi
callq 0x17e00
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2248a3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: remove_dir
static int remove_dir (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	int fail;

	fail = rmdir (path);

	if (fail) {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
	lua_pushboolean (L, 1);
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %rdi
callq 0x172d0
testl %eax, %eax
je 0x23cf87
movq %rbx, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18bb36(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x224708
movl $0x2, %ebp
jmp 0x23cf94
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2248a3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_utime
static int file_utime (lua_State *L) {
	const char *file = luaL_checkstring (L, 1);
	struct utimbuf utb, *buf;

	if (lua_gettop (L) == 1) /* set to current date/time */
		buf = NULL;
	else {
		utb.actime = (time_t)luaL_optnumber (L, 2, 0);
		utb.modtime = (time_t)luaL_optnumber (L, 3, utb.actime);
		buf = &utb;
	}
	if (utime (file, buf)) {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror (errno));
		return 2;
	}
	lua_pushboolean (L, 1);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2235ac
cmpl $0x1, %eax
je 0x23d046
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2272b4
cvttsd2si %xmm0, %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2272b4
cvttsd2si %xmm0, %rax
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x17380
testl %eax, %eax
je 0x23d084
movq %rbx, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18ba39(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x224708
movl $0x2, %ebp
jmp 0x23d096
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2248a3
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_unlock
static int file_unlock (lua_State *L) {
	FILE *fh = check_file (L, 1, "unlock");
	const long start = luaL_optlong (L, 2, 0);
	long len = luaL_optlong (L, 3, 0);
	if (_file_lock (L, fh, "u", start, len, "unlock")) {
		lua_pushboolean (L, 1);
		return 1;
	} else {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x18c1e8(%rip), %r15    # 0x3c929e
movq %r15, %rsi
callq 0x23d3dc
movq %rax, %r12
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x227333
movq %rax, %r13
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x227333
movq %r14, %rdi
movq %r12, %rsi
movl $0x75, %edx
movq %r13, %rcx
movq %rax, %r8
movq %r15, %r9
callq 0x23d42e
testl %eax, %eax
je 0x23d118
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x2248a3
jmp 0x23d140
movq %r14, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18b976(%rip), %rsi    # 0x3c8aa9
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x224708
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: lfs_lock_dir
static int lfs_lock_dir(lua_State *L) {
  lfs_Lock *lock;
  size_t pathl;
  char *ln;
  const char *lockfile = "/lockfile.lfs";
  const char *path = luaL_checklstring(L, 1, &pathl);
  lock = (lfs_Lock*)lua_newuserdata(L, sizeof(lfs_Lock));
  ln = (char*)malloc(pathl + strlen(lockfile) + 1);
  if(!ln) { 
    lua_pushnil(L); lua_pushstring(L, strerror(errno)); return 2;
  }
  strcpy(ln, path); strcat(ln, lockfile);
  if(symlink("lock", ln) == -1) {
    free(ln); lua_pushnil(L); 
    lua_pushstring(L, strerror(errno)); return 2;
  }
  lock->ln = ln;
  luaL_getmetatable (L, LOCK_METATABLE);
  lua_setmetatable (L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x22708d
movq %rax, %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x225cfa
movq %rax, %r14
movq (%r15), %rdi
addq $0xe, %rdi
callq 0x17ff0
testq %rax, %rax
je 0x23d205
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x17770
movq %r15, %rdi
callq 0x172f0
movabsq $0x6c69666b636f6c2f, %rcx # imm = 0x6C69666B636F6C2F
movq %rcx, (%r15,%rax)
movabsq $0x73666c2e656c69, %rcx # imm = 0x73666C2E656C69
movq %rcx, 0x6(%r15,%rax)
leaq 0x198a6c(%rip), %rdi    # 0x3d5c31
movq %r15, %rsi
callq 0x17080
cmpl $-0x1, %eax
je 0x23d1fd
movq %r15, (%r14)
leaq 0x18c076(%rip), %rdx    # 0x3c9252
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224a06
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x225186
movl $0x1, %eax
jmp 0x23d229
movq %r15, %rdi
callq 0x17fe8
movq %rbx, %rdi
callq 0x2241b4
callq 0x17060
movl (%rax), %edi
callq 0x17240
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2243ba
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_info_
static int _file_info_ (lua_State *L, int (*st)(const char*, STAT_STRUCT*)) {
	int i;
	STAT_STRUCT info;
	const char *file = luaL_checkstring (L, 1);

	if (st(file, &info)) {
		lua_pushnil (L);
		lua_pushfstring (L, "cannot obtain information from file `%s'", file);
		return 2;
	}
	if (lua_isstring (L, 2)) {
		int v;
		const char *member = lua_tostring (L, 2);
		if (strcmp (member, "mode") == 0) v = 0;
#ifndef _WIN32
		else if (strcmp (member, "blocks")  == 0) v = 11;
		else if (strcmp (member, "blksize") == 0) v = 12;
#endif
		else /* look for member */
			for (v = 1; members[v].name; v++)
				if (*members[v].name == *member)
					break;
		/* push member value and return */
		members[v].push (L, &info);
		return 1;
	} else if (!lua_istable (L, 2))
		/* creates a table if none is given */
		lua_newtable (L);
	/* stores all members in table on top of the stack */
	for (i = 0; members[i].name; i++) {
		lua_pushstring (L, members[i].name);
		members[i].push (L, &info);
		lua_rawset (L, -3);
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *%r15
movq %rbx, %rdi
testl %eax, %eax
je 0x23d28c
callq 0x2241b4
leaq 0x18c039(%rip), %rsi    # 0x3c92ae
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x224708
movl $0x2, %ebp
jmp 0x23d3cc
movl $0x2, %esi
callq 0x223b1f
testl %eax, %eax
je 0x23d331
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x223ea8
movq %rax, %r14
leaq 0x12cc3a(%rip), %rsi    # 0x369ef4
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x23d3af
leaq 0x108d6b(%rip), %rsi    # 0x34603c
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x23d399
leaq 0x18befb(%rip), %rsi    # 0x3c91e3
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x23d3a1
leaq 0x27dab1(%rip), %rax    # 0x4badb0
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x23d3a9
addq $0x20, %rax
movb (%r14), %sil
movl $0x1, %ecx
cmpb %sil, (%rdx)
je 0x23d32c
incq %rcx
movq (%rax), %rdx
addq $0x10, %rax
testq %rdx, %rdx
jne 0x23d318
movl %ecx, %r15d
jmp 0x23d3af
movq %rbx, %rdi
movl $0x2, %esi
callq 0x223a4b
cmpl $0x5, %eax
je 0x23d34f
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x27da5a(%rip), %r15    # 0x4badb0
movq (%r15), %rsi
movl $0x1, %ebp
testq %rsi, %rsi
je 0x23d3cc
addq $0x10, %r15
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movq %r14, %rsi
callq *-0x8(%r15)
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224fd4
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x23d36c
jmp 0x23d3cc
movl $0xb, %r15d
jmp 0x23d3af
movl $0xc, %r15d
jmp 0x23d3af
movl $0x1, %r15d
shlq $0x4, %r15
leaq 0x27d9f6(%rip), %rax    # 0x4badb0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x8(%rax,%r15)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: check_file
static FILE *check_file (lua_State *L, int idx, const char *funcname) {
	FILE **fh = (FILE **)luaL_checkudata (L, idx, "FILE*");
	if (fh == NULL) {
		luaL_error (L, "%s: not a file", funcname);
		return 0;
	} else if (*fh == NULL) {
		luaL_error (L, "%s: closed file", funcname);
		return 0;
	} else
		return *fh;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18b4bc(%rip), %rdx    # 0x3c88aa
movl $0x1, %esi
callq 0x22712c
testq %rax, %rax
je 0x23d40e
movq (%rax), %r15
testq %r15, %r15
jne 0x23d425
leaq 0x18bf1c(%rip), %rsi    # 0x3c9328
jmp 0x23d415
leaq 0x18bf04(%rip), %rsi    # 0x3c9319
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x226e43
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0xaa(%rip), %rsi        # 0x23d561
xorl %edx, %edx
callq 0x2247b8
leaq 0x18c1c3(%rip), %rdx    # 0x3c9688
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224f78
leaq 0x18c1ba(%rip), %rsi    # 0x3c9693
movq %rbx, %rdi
callq 0x2270b9
movsd 0x10c2f7(%rip), %xmm0   # 0x3497e0
movq %rbx, %rdi
callq 0x2241c8
leaq 0x18c1a8(%rip), %rdx    # 0x3c96a0
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224f78
leaq 0x27d984(%rip), %rdx    # 0x4bae90
movq %rbx, %rdi
xorl %esi, %esi
callq 0x227465
leaq 0x107c97(%rip), %rsi    # 0x3451b4
leaq 0x27d9ec(%rip), %rdx    # 0x4baf10
movq %rbx, %rdi
callq 0x227465
leaq 0x156535(%rip), %rsi    # 0x393a68
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x223a2b
movq %rbx, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x224d62
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x7(%rcx), %r14
shrq $0x3, %r14
leal 0x2(%r14), %eax
movslq %eax, %rbp
movq %rbp, %rsi
callq 0x23d5e1
movq %rax, %r13
cmpl $0x100, %ebp            # imm = 0x100
jl 0x23d5ac
leaq 0x18c10c(%rip), %rsi    # 0x3c96ae
movq %r12, %rdi
xorl %eax, %eax
callq 0x226e43
movb $0x11, (%r13)
movb %r14b, 0x1(%r13)
movw $0x0, 0x2(%r13)
movq %r15, 0x8(%r13)
addq $0x10, %r13
movq %r13, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17660
// File: /workspace/github_c_makefile_star2_O3/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 0x23d606
leaq 0x18c0c8(%rip), %rsi    # 0x3c96c4
movq %r14, %rdi
xorl %eax, %eax
callq 0x226e43
leaq 0x8(,%rbx,8), %rsi
movq %r14, %rdi
callq 0x225cfa
movq %rax, %r15
leaq 0x18c073(%rip), %rdx    # 0x3c9693
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224a06
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x225186
movl $0x6, (%r15,%rbx,8)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23dd8d
movq %rax, %r14
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x23dd8d
movb (%r14), %cl
cmpb $0xf, %cl
jne 0x23d694
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x23d6d1
cmpb $0x6, %cl
je 0x23d6c9
cmpb $0xf, (%rax)
je 0x23d6c9
leaq 0xc(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x23e4cd
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %ecx
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r9
callq 0x23e58c
jmp 0x23d6d6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x223a2b
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23dd8d
movq %rax, %r15
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x23dd8d
movq %rax, %r14
leaq 0x2c(%rsp), %rsi
movq %r15, %rdi
callq 0x23e4cd
cmpl $0x1, %eax
jne 0x23da3f
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23e4cd
cmpl $0x1, %eax
jne 0x23da3f
movl $0x5, %esi
movq %rbx, %rdi
callq 0x23d5e1
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 0x23da1f
jmp 0x23db09
movq %r14, %rdi
callq 0x23f3f6
movl (%rsp), %ecx
movl 0x4(%rsp), %edx
testl %eax, %eax
je 0x23daad
leal (%rcx,%rdx), %eax
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x23d5e1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x23ebf1
movslq %eax, %r15
leaq (%r14,%r15,8), %rdi
movslq (%rsp), %rax
leal 0x1(%rax), %esi
shlq $0x3, %rax
subq %rax, %rdi
callq 0x23f482
leaq (%r14,%r15,8), %rsi
addq $0x8, %rsi
movl $0xf, -0x8(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x23ebf1
jmp 0x23db09
leal (%rcx,%rdx), %eax
addl $0x2, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x23d5e1
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 0x23ebf1
cltq
leaq (%r14,%rax,8), %rsi
addq $0x10, %rsi
movl $0xe, -0x8(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x23ebf1
movq %r14, %rdi
callq 0x23f4bf
movl $0x1, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23dd8d
movq %rax, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x23dd8d
movzbl (%r14), %ecx
cmpl $0xf, %ecx
je 0x23db57
movzbl (%rax), %edx
cmpl $0xf, %edx
je 0x23db6a
cmpl $0x6, %edx
jne 0x23db61
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x23db72
testl %ecx, %ecx
je 0x23db84
cmpl $0x6, %ecx
jne 0x23dbae
movq %rbx, %rdi
movl $0x2, %esi
callq 0x223a2b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb %dl, %dl
jne 0x23dbae
cmpb $0x6, 0x8(%r14)
jne 0x23dbae
cmpb $0x6, 0x8(%rax)
jne 0x23dbae
movzbl 0x1(%r14), %ecx
movzbl 0x1(%rax), %esi
addl %ecx, %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x23ea6b
jmp 0x23db77
movslq 0x4(%rsp), %rax
movslq (%rsp), %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x23d5e1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x23ebf1
cltq
leaq (%r14,%rax,8), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x23ebf1
movq %r14, %rdi
callq 0x23f626
jmp 0x23db77
// File: /workspace/github_c_makefile_star2_O3/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 0x223a4b
cmpl $0x4, %eax
je 0x23dc23
cmpl $0x5, %eax
je 0x23dc19
cmpl $0x6, %eax
jne 0x23dc3c
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x23dc2b
movq %rbx, %rdi
movl $0x8, %esi
jmp 0x23dc2b
movq %rbx, %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x23f8b7
movl $0x1, %eax
popq %rbx
retq
leaq 0x18bf17(%rip), %rdx    # 0x3c9b5a
movq %rbx, %rdi
movl $0x2, %esi
popq %rbx
jmp 0x226d91
// File: /workspace/github_c_makefile_star2_O3/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 0x23dd8d
movzbl (%rax), %eax
cmpl $0x6, %eax
je 0x23dc7a
cmpl $0xf, %eax
jne 0x23dc8f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x23d5e1
jmp 0x23dcb5
movl $0x1, %esi
movq %rbx, %rdi
callq 0x23d5e1
movl $0xf, (%rax)
jmp 0x23dcb5
leaq 0x18b94e(%rip), %rsi    # 0x3c95e4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2241f7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2237fd
movq %rbx, %rdi
callq 0x23d9a3
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23dd8d
movq %rax, %r14
movzbl (%rax), %eax
cmpl $0xf, %eax
je 0x23dce3
cmpl $0x6, %eax
jne 0x23dcfd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x223a2b
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x23e4cd
movslq (%rsp), %rsi
cmpl $0x1, %eax
jne 0x23dd41
incq %rsi
movq %rbx, %rdi
callq 0x23d5e1
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 0x23dcf0
addl $0x3, %esi
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x23d5e1
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 0x23ebf1
cltq
movl $0x2000d, 0x8(%r14,%rax,8) # imm = 0x2000D
movl $0xf, 0x10(%r14,%rax,8)
jmp 0x23dcf0
// File: /workspace/github_c_makefile_star2_O3/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 0x23e589
cmpw $0x0, 0x2(%rdi)
jne 0x23e589
leaq 0x4(%rsi), %rax
cmpl $0x2, %ecx
je 0x23e51e
cmpl $0x1, %ecx
jne 0x23e532
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 0x23e53f
xorl %ecx, %ecx
movb 0x8(%rdi,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq $0x20, %rcx
jne 0x23e520
jmp 0x23e53f
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 0x23e56f
cmpl $0x11, %edx
jne 0x23e56a
movzbl 0x1(%rdi), %ecx
movl $0x1, %eax
cmpb $0x6, 0x10(%rdi,%rcx,8)
jne 0x23e584
jmp 0x23e589
movl $0x1, %eax
cmpb $0x6, (%rdi,%rax,8)
jne 0x23e584
movl $0x1, %eax
testb %cl, %cl
jne 0x23e589
cmpb $0x1, 0x1(%rdi)
je 0x23e589
movl $0x2, %eax
movl %eax, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23ea80
movslq (%rbx), %r15
jmp 0x23ea83
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 0x23d5e1
leaq (%rax,%r15,8), %rcx
cmpl $0x100, %r14d           # imm = 0x100
jl 0x23ead6
movl %r14d, %edx
movl $0xff00, (%rcx)         # imm = 0xFF00
addq $0x8, %rcx
leal -0xff(%rdx), %r14d
cmpl $0x1fe, %edx            # imm = 0x1FE
ja 0x23eaba
movb $0x0, (%rcx)
movw $0x0, 0x2(%rcx)
movb %r14b, 0x1(%rcx)
testq %rbx, %rbx
je 0x23eaf5
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_O3/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 0x224be0
movq %r14, %rdi
movl %ebx, %esi
callq 0x223a2b
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x2250be
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22523b
// File: /workspace/github_c_makefile_star2_O3/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 0x224118
xorl %ebx, %ebx
testq %rax, %rax
je 0x23eb9f
movq %r14, %rdi
movl %ebp, %esi
callq 0x224cb7
testl %eax, %eax
je 0x23eb9f
leaq 0x18ab29(%rip), %rdx    # 0x3c9693
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224a06
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x223b5e
testl %eax, %eax
je 0x23eb9f
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x2235b9
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x223ea8
testq %rax, %rax
je 0x23ebc3
leaq 0x18abeb(%rip), %rsi    # 0x3c97ac
jmp 0x23ebde
movq %rbx, %rdi
movl %ebp, %esi
callq 0x223a4b
movq %rbx, %rdi
movl %eax, %esi
callq 0x223a66
leaq 0x18abd8(%rip), %rsi    # 0x3c97b6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224708
// File: /workspace/github_c_makefile_star2_O3/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 0x224118
movq %rax, %r12
movq %r15, %rdi
movl %r14d, %esi
callq 0x223f77
movq %rax, %r13
shrq $0x3, %r13
leal -0x1(%r13), %ebp
movq %r15, %rdi
movl %r14d, %esi
callq 0x23edd1
movl %eax, %r14d
movslq %r13d, %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17660
testl %r14d, %r14d
je 0x23ec9d
testl %ebp, %ebp
jle 0x23ec9d
movslq %ebp, %rax
leaq (%rbx,%rax,8), %rax
movl $0xbfbff, %ecx          # imm = 0xBFBFF
movzbl (%rbx), %edx
btq %rdx, %rcx
jb 0x23ec73
movzwl 0x2(%rbx), %esi
testw %si, %si
je 0x23ec73
addl %r14d, %esi
movw %si, 0x2(%rbx)
movl $0x5, %esi
leal -0x2(%rdx), %edi
cmpl $0x2, %edi
jb 0x23ec94
cmpl $0x11, %edx
jne 0x23ec8f
movzbl 0x1(%rbx), %esi
addq $0x2, %rsi
jmp 0x23ec94
movl $0x1, %esi
leaq (%rbx,%rsi,8), %rbx
cmpq %rax, %rbx
jb 0x23ec5a
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_O3/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 0x224d0c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebp, %edx
callq 0x224b36
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x223e53
movq %rax, %r14
testl %r14d, %r14d
je 0x23ed08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x2235b9
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %ebp, %edx
callq 0x224b36
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x23eba6
leaq 0x18ac83(%rip), %rsi    # 0x3c99ae
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x226e43
// File: /workspace/github_c_makefile_star2_O3/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), %sil
cmpb $0x6, %sil
je 0x23edd0
xorl %ecx, %ecx
movl $0xfdc478, %eax         # imm = 0xFDC478
movq %rdi, %rdx
movzbl %sil, %esi
btq %rsi, %rax
jb 0x23ed97
movswl 0x2(%rdx), %r9d
testl %r9d, %r9d
je 0x23ed97
addl %ecx, %r9d
movslq %r9d, %r8
cmpb $0x8, (%rdi,%r8,8)
jne 0x23ed8c
movswq 0x2(%rdi,%r8,8), %r10
movslq %r9d, %r8
addq %r10, %r8
cmpb $0x8, (%rdi,%r8,8)
movl %r8d, %r9d
je 0x23ed74
jmp 0x23ed8f
movl %r9d, %r8d
subl %ecx, %r8d
movw %r8w, 0x2(%rdx)
movl $0x5, %r8d
leal -0x2(%rsi), %r9d
cmpl $0x2, %r9d
jb 0x23edbd
cmpl $0x11, %esi
jne 0x23edb7
movzbl 0x1(%rdx), %r8d
addl $0x2, %r8d
jmp 0x23edbd
movl $0x1, %r8d
addl %ecx, %r8d
leaq (%rdi,%r8,8), %rdx
movb (%rdx), %sil
movl %r8d, %ecx
cmpb $0x6, %sil
jne 0x23ed53
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x224d0c
movq %rbx, %rdi
callq 0x23ef17
movl %eax, %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x224d0c
testl %r14d, %r14d
je 0x23ee15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x223bf0
testl %eax, %eax
je 0x23ee32
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x2235b9
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x23ef17
testl %eax, %eax
je 0x23eef8
movl %eax, %r15d
leal (%r15,%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x224be0
testl %r15d, %r15d
jle 0x23ee97
movl %r15d, %r13d
negl %r13d
movl $0x1, %r12d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r12d, %edx
callq 0x224b36
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r12d, %edx
callq 0x2250be
leal (%r12,%r13), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x23ee64
testl %r14d, %r14d
jle 0x23eed9
negl %r14d
movl $0x1, %r12d
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %r12d, %edx
callq 0x224b36
leal (%r15,%r12), %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2250be
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x23eea5
movq %rbx, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x22523b
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x2235b9
jmp 0x23ee25
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2235b9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22523b
jmp 0x23ee22
// File: /workspace/github_c_makefile_star2_O3/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 0x23d5e1
movq %rax, (%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x23edd1
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_O3/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 0x23f40d
cmpw $0x0, 0x2(%rdi)
je 0x23f40e
retq
movl $0x5, %ecx
leal -0x2(%rdx), %esi
cmpl $0x2, %esi
jb 0x23f42f
cmpl $0x11, %edx
jne 0x23f42a
movzbl 0x1(%rdi), %ecx
addq $0x2, %rcx
jmp 0x23f42f
movl $0x1, %ecx
movb (%rdi,%rcx,8), %sil
cmpb $0x6, %sil
je 0x23f47c
leaq (%rdi,%rcx,8), %rcx
movl $0x83fef7, %edx         # imm = 0x83FEF7
movzbl %sil, %edi
btq %rdi, %rdx
jb 0x23f40d
movl $0x5, %esi
leal -0x2(%rdi), %r8d
cmpl $0x2, %r8d
jb 0x23f46f
cmpl $0x11, %edi
jne 0x23f46a
movzbl 0x1(%rcx), %esi
addq $0x2, %rsi
jmp 0x23f46f
movl $0x1, %esi
leaq (%rcx,%rsi,8), %rcx
movb (%rcx), %sil
cmpb $0x6, %sil
jne 0x23f442
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23f558
movq %rdi, %rbx
movzbl 0x8(%rdi), %eax
leaq -0x3(%rax), %rcx
cmpq $0x15, %rcx
jb 0x23f553
cmpw $0x0, 0xa(%rbx)
jne 0x23f553
movl $0x5, %ebp
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jb 0x23f504
cmpl $0x11, %eax
jne 0x23f4ff
movzbl 0x9(%rbx), %ebp
addl $0x2, %ebp
jmp 0x23f504
movl $0x1, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x23f596
movzbl (%rbx), %eax
leaq -0x3(%rax), %rcx
cmpq $0x15, %rcx
jb 0x23f577
cmpw $0x0, 0x2(%rbx)
jne 0x23f577
movl %ebp, %r14d
cmpb $0x7, (%rbx,%r14,8)
jne 0x23f577
movb $0x1, %cl
testb %al, %al
jne 0x23f53a
movb 0x1(%rbx), %cl
movb %cl, 0x1(%rbx,%r14,8)
movswl 0x2(%rbx,%r14,8), %esi
movq %rbx, %rdi
callq 0x23f482
subw %bp, 0x2(%rbx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18a4ab(%rip), %rdi    # 0x3c9a0a
leaq 0x18a17c(%rip), %rsi    # 0x3c96e2
leaq 0x18a4b2(%rip), %rcx    # 0x3c9a1f
movl $0x398, %edx            # imm = 0x398
callq 0x174d0
leaq 0x18a4c4(%rip), %rdi    # 0x3c9a42
leaq 0x18a15d(%rip), %rsi    # 0x3c96e2
leaq 0x18a493(%rip), %rcx    # 0x3c9a1f
movl $0x39c, %edx            # imm = 0x39C
callq 0x174d0