// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: verify
static int verify (lua_State *L, Instruction *op, const Instruction *p,
                   Instruction *e, int postable, int rule) {
  static const char dummy[] = "";
  Stack back[MAXBACKVER];
  int backtop = 0;  /* point to first empty slot in back */
  while (p != e) {
    switch ((Opcode)p->i.code) {
      case IRet: {
        p = back[--backtop].p;
        continue;
      }
      case IChoice: {
        if (backtop >= MAXBACKVER)
          return luaL_error(L, "too many pending calls/choices");
        back[backtop].p = dest(0, p);
        back[backtop++].s = dummy;
        p++;
        continue;
      }
      case ICall: {
        assert((p + 1)->i.code != IRet);  /* no tail call */
        if (backtop >= MAXBACKVER)
          return luaL_error(L, "too many pending calls/choices");
        back[backtop].s = NULL;
        back[backtop++].p = p + 1;
        goto dojmp;
      }
      case IOpenCall: {
        int i;
        if (postable == 0)  /* grammar still not fixed? */
          goto fail;  /* to be verified later */
        for (i = 0; i < backtop; i++) {
          if (back[i].s == NULL && back[i].p == p + 1)
            return luaL_error(L, "%s is left recursive", val2str(L, rule));
        }
        if (backtop >= MAXBACKVER)
          return luaL_error(L, "too many pending calls/choices");
        back[backtop].s = NULL;
        back[backtop++].p = p + 1;
        p = op + getposition(L, postable, p->i.offset);
        continue;
      }
      case IBackCommit:
      case ICommit: {
        assert(backtop > 0 && p->i.offset > 0);
        backtop--;
        goto dojmp;
      }
      case IPartialCommit: {
        assert(backtop > 0);
        if (p->i.offset > 0) goto dojmp;  /* forward jump */
        else {  /* loop will be detected when checking corresponding rule */
          assert(postable != 0);
          backtop--;
          p++;  /* just go on now */
          continue;
        }
      }
      case IBack: {
        if (p->i.aux == 1 && isfixcheck(p + 1)) {  /* char test? */
          p++;  /* skip back instruction */
          p += sizei(p);  /* skip char test */
        }
        else {  /* standard lookbehind code */
          assert((Opcode)(p - 1)->i.code == IChoice);  /* look behind */
          backtop--;
          p += (p - 1)->i.offset;
          assert((Opcode)(p - 1)->i.code == IFail);  /* look behind */
        }
        continue;
      }
      case IAny:
      case IChar:
      case ISet: {
        const Instruction *next = p + sizei(p);
        if ((Opcode)next->i.code == IBack)
          p = next + 1;  /* continue after the back instruction */
        else if (p->i.offset == 0) goto fail;
        else  /* jump */
          p += p->i.offset;
        continue;
      }
      case IJmp:
      dojmp: {
        p += p->i.offset;
        continue;
      }
      case IFailTwice:  /* 'not' predicate */
        goto fail;  /* body could have failed; try to backtrack it */
      case IFail: {
        if (p > op && (p - 1)->i.code == IBackCommit) {  /* 'and' predicate? */
          p++;  /* pretend it succeeded and go ahead */
          continue;
        }
        /* else failed: go through */
      }
      fail: { /* pattern failed: try to backtrack */
        do {
          if (backtop-- == 0)
            return 1;  /* no more backtracking */
        } while (back[backtop].s == NULL);
        p = back[backtop].p;
        continue;
      }
      case ISpan:
      case IOpenCapture: case ICloseCapture:
      case IEmptyCapture: case IEmptyCaptureIdx:
      case IFullCapture: {
        p += sizei(p);
        continue;
      }
      case ICloseRunTime: {
        goto fail;  /* be liberal in this case */
      }
      case IFunc: {
        const char *r = (p+1)->f(dummy, dummy, dummy, (p+2)->buff);
        if (r != NULL) { p += funcinstsize(p); }
        else condfailed(p);
        continue;
      }
      case IEnd:  /* cannot happen (should stop before it) */
      default: assert(0); return 0;
    }
  }
  assert(backtop == 0);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x12e8, %rsp           # imm = 0x12E8
cmpq %rcx, %rdx
je 0x247d45
movl %r8d, %r13d
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %rbp
leaq 0x28(%rsp), %r8
leaq 0x18b23c(%rip), %r14    # 0x3d2bb0
leaq 0x18b389(%rip), %r10    # 0x3d2d04
leaq 0x18b621(%rip), %rsi    # 0x3d2fa3
xorl %r12d, %r12d
movzbl (%rbx), %ecx
cmpq $0x17, %rcx
ja 0x247ddb
movl $0x5, %eax
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movl $0x1, %eax
jmp 0x247b3a
testl %r12d, %r12d
jle 0x247d7e
cmpw $0x0, 0x2(%rbx)
jle 0x247d7e
decl %r12d
jmp 0x247b35
movl $0x1, %eax
cmpb $0x4, (%rbx,%rax,8)
jne 0x2479db
leaq (%rbx,%rax,8), %rbx
addq $0x8, %rbx
jmp 0x2479ed
movswq 0x2(%rbx), %rax
testq %rax, %rax
je 0x247ba6
leaq (%rbx,%rax,8), %rbx
movb $0x1, %al
testb %al, %al
jne 0x247b3e
jmp 0x247c7c
testl %r13d, %r13d
je 0x247bad
testl %r12d, %r12d
movl %r9d, 0x4(%rsp)
jle 0x247a3c
leaq 0x8(%rbx), %rax
movl %r12d, %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
cmpq $0x0, 0x20(%rsp,%rdx)
jne 0x247a33
cmpq %rax, 0x28(%rsp,%rdx)
je 0x247cae
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x247a20
cmpl $0xc8, %r12d
jl 0x247c12
movq %rbp, 0x8(%rsp)
movl %r13d, (%rsp)
movq %rdi, %r13
xorl %eax, %eax
movq %rsi, %rbp
callq 0x230abd
movq %rbp, %rsi
movq %r13, %rdi
movl (%rsp), %r13d
movq 0x8(%rsp), %rbp
movl %eax, 0x14(%rsp)
movl $0x1, %eax
jmp 0x247c59
cmpb $0x5, 0x8(%rbx)
je 0x247d9d
cmpl $0xc7, %r12d
jg 0x247d59
leaq 0x8(%rbx), %rax
movslq %r12d, %rcx
leaq (%rcx,%rcx,2), %rcx
movq $0x0, 0x20(%rsp,%rcx,8)
incl %r12d
movq %rax, 0x28(%rsp,%rcx,8)
jmp 0x247b35
cmpb $0x1, 0x1(%rbx)
jne 0x247ad3
movzbl 0x8(%rbx), %eax
leaq -0x3(%rax), %rcx
cmpq $0x15, %rcx
jb 0x247ad3
cmpw $0x0, 0xa(%rbx)
je 0x247d07
cmpb $0x7, -0x8(%rbx)
jne 0x247dfa
movswq -0x6(%rbx), %rax
cmpb $0xf, -0x8(%rbx,%rax,8)
jne 0x247e19
decl %r12d
jmp 0x247b3a
cmpl $0xc7, %r12d
jg 0x247d59
movswq 0x2(%rbx), %rax
leaq (%rbx,%rax,8), %rax
movslq %r12d, %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rax, 0x28(%rsp,%rcx,8)
incl %r12d
movq %r10, 0x20(%rsp,%rcx,8)
jmp 0x247c09
testl %r12d, %r12d
jle 0x247dbc
cmpw $0x0, 0x2(%rbx)
jle 0x247bfd
movswq 0x2(%rbx), %rax
leaq (%rbx,%rax,8), %rbx
cmpq %r15, %rbx
jne 0x247985
jmp 0x247d3c
movq %rbp, 0x8(%rsp)
movl %r13d, (%rsp)
movq %rdi, 0x18(%rsp)
movl %r9d, %ebp
leaq 0x10(%rbx), %rcx
movq %r10, %rdi
movq %r10, %rsi
movq %r10, %r13
movq %r10, %rdx
callq *0x8(%rbx)
testq %rax, %rax
je 0x247bb7
movzbl 0x1(%rbx), %eax
addq $0x2, %rax
xorl %ecx, %ecx
jmp 0x247bc2
cmpq %rbp, %rbx
jbe 0x247c7c
cmpb $0xd, -0x8(%rbx)
je 0x247c09
jmp 0x247c7c
decl %r12d
movslq %r12d, %rax
leaq (%rax,%rax,2), %rax
movq 0x28(%rsp,%rax,8), %rbx
jmp 0x247b3e
xorl %eax, %eax
jmp 0x2479ef
movl $0x6, %eax
jmp 0x247c6a
movswq 0x2(%rbx), %rax
testq %rax, %rax
sete %cl
testb %cl, %cl
movl %ebp, %r9d
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r8
movq %r13, %r10
leaq 0x18b3c8(%rip), %rsi    # 0x3d2fa3
je 0x247beb
movl (%rsp), %r13d
movq 0x8(%rsp), %rbp
jmp 0x247c7c
leaq (%rbx,%rax,8), %rbx
movl (%rsp), %r13d
movq 0x8(%rsp), %rbp
jmp 0x247b3e
testl %r13d, %r13d
je 0x247e57
decl %r12d
addq $0x8, %rbx
jmp 0x247b3e
movslq %r12d, %rax
leaq (%rax,%rax,2), %rax
movq $0x0, 0x20(%rsp,%rax,8)
leaq 0x8(%rbx), %rcx
incl %r12d
movq %rcx, 0x28(%rsp,%rax,8)
movswl 0x2(%rbx), %edx
movq %rdi, %rbx
movl %r13d, %esi
callq 0x2476b8
leaq 0x18b35f(%rip), %rsi    # 0x3d2fa3
movq %rbx, %rdi
cltq
leaq (,%rax,8), %rbx
addq %rbp, %rbx
movl $0x2, %eax
movl 0x4(%rsp), %r9d
leaq 0x28(%rsp), %r8
leaq 0x18b09a(%rip), %r10    # 0x3d2d04
cmpl $0x2, %eax
je 0x247b3e
cmpl $0x6, %eax
jne 0x247d78
movslq %r12d, %rax
leaq (%rax,%rax,2), %rcx
leaq (%r8,%rcx,8), %rdx
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x247d35
incq %rcx
leaq -0x18(%rdx), %r11
cmpq $0x0, -0x20(%rdx)
movq %r11, %rdx
je 0x247c89
subl %ecx, %r12d
movq (%r11), %rbx
jmp 0x247b3e
movl %r13d, (%rsp)
movq %rdi, %r13
movl %r9d, %esi
movq %rbp, 0x8(%rsp)
movq %r10, %rbp
callq 0x2475ae
movq %r13, %rdi
leaq 0x18b360(%rip), %rsi    # 0x3d302f
movq %rax, %rdx
xorl %eax, %eax
callq 0x230abd
leaq 0x18b2c3(%rip), %rsi    # 0x3d2fa3
movq %rbp, %r10
leaq 0x28(%rsp), %r8
movq %r13, %rdi
movl (%rsp), %r13d
movl 0x4(%rsp), %r9d
movq 0x8(%rsp), %rbp
movl %eax, 0x14(%rsp)
movl $0x1, %eax
jmp 0x247c6a
movl $0x5, %ecx
leal -0x2(%rax), %edx
cmpl $0x2, %edx
jb 0x247d28
cmpl $0x11, %eax
jne 0x247d23
movzbl 0x9(%rbx), %ecx
addq $0x2, %rcx
jmp 0x247d28
movl $0x1, %ecx
addq $0x8, %rbx
leaq (%rbx,%rcx,8), %rbx
jmp 0x247b3e
movl $0x1, %eax
jmp 0x247d47
testl %r12d, %r12d
jne 0x247e38
xorl %eax, %eax
addq $0x12e8, %rsp           # imm = 0x12E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18b243(%rip), %rsi    # 0x3d2fa3
xorl %eax, %eax
addq $0x12e8, %rsp           # imm = 0x12E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x230abd
movl 0x14(%rsp), %eax
jmp 0x247d47
leaq 0x18b2bf(%rip), %rdi    # 0x3d3044
leaq 0x18b076(%rip), %rsi    # 0x3d2e02
leaq 0x18b247(%rip), %rcx    # 0x3d2fda
movl $0x2bc, %edx            # imm = 0x2BC
callq 0x174d0
leaq 0x18b21e(%rip), %rdi    # 0x3d2fc2
leaq 0x18b057(%rip), %rsi    # 0x3d2e02
leaq 0x18b228(%rip), %rcx    # 0x3d2fda
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x174d0
leaq 0x18b2a0(%rip), %rdi    # 0x3d3063
leaq 0x18b038(%rip), %rsi    # 0x3d2e02
leaq 0x18b209(%rip), %rcx    # 0x3d2fda
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x174d0
leaq 0x12fe6b(%rip), %rdi    # 0x377c4d
leaq 0x18b019(%rip), %rsi    # 0x3d2e02
leaq 0x18b1ea(%rip), %rcx    # 0x3d2fda
movl $0x309, %edx            # imm = 0x309
callq 0x174d0
leaq 0x18b27c(%rip), %rdi    # 0x3d307d
leaq 0x18affa(%rip), %rsi    # 0x3d2e02
leaq 0x18b1cb(%rip), %rcx    # 0x3d2fda
movl $0x2d0, %edx            # imm = 0x2D0
callq 0x174d0
leaq 0x18b280(%rip), %rdi    # 0x3d30a0
leaq 0x18afdb(%rip), %rsi    # 0x3d2e02
leaq 0x18b1ac(%rip), %rcx    # 0x3d2fda
movl $0x2d3, %edx            # imm = 0x2D3
callq 0x174d0
leaq 0x18b282(%rip), %rdi    # 0x3d30c1
leaq 0x18afbc(%rip), %rsi    # 0x3d2e02
leaq 0x18b18d(%rip), %rcx    # 0x3d2fda
movl $0x30c, %edx            # imm = 0x30C
callq 0x174d0
leaq 0x18b211(%rip), %rdi    # 0x3d306f
leaq 0x18af9d(%rip), %rsi    # 0x3d2e02
leaq 0x18b16e(%rip), %rcx    # 0x3d2fda
movl $0x2c4, %edx            # imm = 0x2C4
callq 0x174d0