/* -*- mode: C; buffer-read-only: t -*-
   !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
   This file is built by regen/regcomp.pl from regcomp.sym, op_reg_common.h
   and regexp.h.
   Any changes made here will be lost!
 */

#if defined(PERL_CORE) || defined(PERL_EXT_RE_BUILD)


/* typedefs for regex nodes - one typedef per node type */

typedef struct regnode_2                         tregnode_ACCEPT;
typedef struct regnode_1                         tregnode_AHOCORASICK;
typedef struct regnode_charclass                 tregnode_AHOCORASICKC;
typedef struct regnode_charclass                 tregnode_ANYOF;
typedef struct regnode_charclass                 tregnode_ANYOFD;
typedef struct regnode_1                         tregnode_ANYOFH;
typedef struct regnode_1                         tregnode_ANYOFHb;
typedef struct regnode_bbm                       tregnode_ANYOFHbbm;
typedef struct regnode_1                         tregnode_ANYOFHr;
typedef struct regnode_1                         tregnode_ANYOFHs;
typedef struct regnode_charclass                 tregnode_ANYOFL;
typedef struct regnode_1                         tregnode_ANYOFM;
typedef struct regnode_charclass_posixl          tregnode_ANYOFPOSIXL;
typedef struct regnode_1                         tregnode_ANYOFR;
typedef struct regnode_1                         tregnode_ANYOFRb;
typedef struct regnode                           tregnode_BOUND;
typedef struct regnode                           tregnode_BOUNDA;
typedef struct regnode                           tregnode_BOUNDL;
typedef struct regnode                           tregnode_BOUNDU;
typedef struct regnode_1                         tregnode_BRANCH;
typedef struct regnode_2                         tregnode_BRANCHJ;
typedef struct regnode_1                         tregnode_CLOSE;
typedef struct regnode                           tregnode_CLUMP;
typedef struct regnode_1                         tregnode_COMMIT;
typedef struct regnode_3                         tregnode_CURLY;
typedef struct regnode_3                         tregnode_CURLYM;
typedef struct regnode_3                         tregnode_CURLYN;
typedef struct regnode_3                         tregnode_CURLYX;
typedef struct regnode_1                         tregnode_CUTGROUP;
typedef struct regnode_1                         tregnode_DEFINEP;
typedef struct regnode                           tregnode_END;
typedef struct regnode                           tregnode_ENDLIKE;
typedef struct regnode                           tregnode_EOS;
typedef struct regnode_2                         tregnode_EVAL;
typedef struct regnode                           tregnode_EXACT;
typedef struct regnode                           tregnode_EXACTF;
typedef struct regnode                           tregnode_EXACTFAA;
typedef struct regnode                           tregnode_EXACTFAA_NO_TRIE;
typedef struct regnode                           tregnode_EXACTFL;
typedef struct regnode                           tregnode_EXACTFLU8;
typedef struct regnode                           tregnode_EXACTFU;
typedef struct regnode                           tregnode_EXACTFUP;
typedef struct regnode                           tregnode_EXACTFU_REQ8;
typedef struct regnode                           tregnode_EXACTFU_S_EDGE;
typedef struct regnode                           tregnode_EXACTL;
typedef struct regnode                           tregnode_EXACT_REQ8;
typedef struct regnode_2                         tregnode_GOSUB;
typedef struct regnode                           tregnode_GPOS;
typedef struct regnode_1                         tregnode_GROUPP;
typedef struct regnode_1                         tregnode_GROUPPN;
typedef struct regnode_1                         tregnode_IFMATCH;
typedef struct regnode_1                         tregnode_IFTHEN;
typedef struct regnode_1                         tregnode_INSUBP;
typedef struct regnode                           tregnode_KEEPS;
typedef struct regnode_1                         tregnode_LEXACT;
typedef struct regnode_1                         tregnode_LEXACT_REQ8;
typedef struct regnode                           tregnode_LNBREAK;
typedef struct regnode                           tregnode_LOGICAL;
typedef struct regnode_1                         tregnode_LONGJMP;
typedef struct regnode                           tregnode_LOOKBEHIND_END;
typedef struct regnode_2                         tregnode_LTRIE;
typedef struct regnode_charclass_trie            tregnode_LTRIEC;
typedef struct regnode_1                         tregnode_MARKPOINT;
typedef struct regnode                           tregnode_MBOL;
typedef struct regnode                           tregnode_MEOL;
typedef struct regnode                           tregnode_MINMOD;
typedef struct regnode_1                         tregnode_NANYOFM;
typedef struct regnode                           tregnode_NBOUND;
typedef struct regnode                           tregnode_NBOUNDA;
typedef struct regnode                           tregnode_NBOUNDL;
typedef struct regnode                           tregnode_NBOUNDU;
typedef struct regnode                           tregnode_NOTHING;
typedef struct regnode                           tregnode_NPOSIXA;
typedef struct regnode                           tregnode_NPOSIXD;
typedef struct regnode                           tregnode_NPOSIXL;
typedef struct regnode                           tregnode_NPOSIXU;
typedef struct regnode_1                         tregnode_OPEN;
typedef struct regnode_1                         tregnode_OPFAIL;
typedef struct regnode                           tregnode_OPTIMIZED;
typedef struct regnode                           tregnode_PLUS;
typedef struct regnode                           tregnode_POSIXA;
typedef struct regnode                           tregnode_POSIXD;
typedef struct regnode                           tregnode_POSIXL;
typedef struct regnode                           tregnode_POSIXU;
typedef struct regnode_1                         tregnode_PRUNE;
typedef struct regnode                           tregnode_PSEUDO;
typedef struct regnode_2                         tregnode_REF;
typedef struct regnode_2                         tregnode_REFF;
typedef struct regnode_2                         tregnode_REFFA;
typedef struct regnode_2                         tregnode_REFFAN;
typedef struct regnode_2                         tregnode_REFFL;
typedef struct regnode_2                         tregnode_REFFLN;
typedef struct regnode_2                         tregnode_REFFN;
typedef struct regnode_2                         tregnode_REFFU;
typedef struct regnode_2                         tregnode_REFFUN;
typedef struct regnode_2                         tregnode_REFN;
typedef struct regnode_p                         tregnode_REGEX_SET;
typedef struct regnode                           tregnode_REG_ANY;
typedef struct regnode_1                         tregnode_RENUM;
typedef struct regnode                           tregnode_SANY;
typedef struct regnode                           tregnode_SBOL;
typedef struct regnode                           tregnode_SEOL;
typedef struct regnode_1                         tregnode_SKIP;
typedef struct regnode                           tregnode_SRCLOSE;
typedef struct regnode                           tregnode_SROPEN;
typedef struct regnode                           tregnode_STAR;
typedef struct regnode                           tregnode_SUCCEED;
typedef struct regnode_1                         tregnode_SUSPEND;
typedef struct regnode                           tregnode_TAIL;
typedef struct regnode_1                         tregnode_TRIE;
typedef struct regnode_charclass                 tregnode_TRIEC;
typedef struct regnode_1                         tregnode_UNLESSM;
typedef struct regnode_1                         tregnode_VERB;
typedef struct regnode                           tregnode_WHILEM;

/* end typedefs */

/* Regops and State definitions */

#define REGNODE_MAX           	113
#define REGMATCH_STATE_MAX    	157

/* -- For regexec.c to switch on target being utf8 (t8) or not (tb, b='byte'); */
#define with_t_UTF8ness(op, t_utf8) (((op) << 1) + (cBOOL(t_utf8)))
/* -- same, but also with pattern (p8, pb) -- */
#define with_tp_UTF8ness(op, t_utf8, p_utf8)                        \
		(((op) << 2) + (cBOOL(t_utf8) << 1) + cBOOL(p_utf8))

/* The #defines below give both the basic regnode and the expanded version for
   switching on utf8ness */
/* 0x00 :   0
   END - End of program. */
#define END                         0
#define END_tb                      ((END) * 2)
#define END_t8                      ((END) * 2 + 1)
#define END_tb_pb                   ((END) * 4)
#define END_tb_p8                   ((END) * 4 + 1)
#define END_t8_pb                   ((END) * 4 + 2)
#define END_t8_p8                   ((END) * 4 + 3)

/* 0x01 :   1
   SUCCEED - Return from a subroutine, basically. */
#define SUCCEED                     (END + 1)
#define SUCCEED_tb                  ((SUCCEED) * 2)
#define SUCCEED_t8                  ((SUCCEED) * 2 + 1)
#define SUCCEED_tb_pb               ((SUCCEED) * 4)
#define SUCCEED_tb_p8               ((SUCCEED) * 4 + 1)
#define SUCCEED_t8_pb               ((SUCCEED) * 4 + 2)
#define SUCCEED_t8_p8               ((SUCCEED) * 4 + 3)

/* 0x02 :   2
   LOOKBEHIND_END - Return from lookbehind (IFMATCH/UNLESSM) and validate
   position when they do */
#define LOOKBEHIND_END              (SUCCEED + 1)
#define LOOKBEHIND_END_tb           ((LOOKBEHIND_END) * 2)
#define LOOKBEHIND_END_t8           ((LOOKBEHIND_END) * 2 + 1)
#define LOOKBEHIND_END_tb_pb        ((LOOKBEHIND_END) * 4)
#define LOOKBEHIND_END_tb_p8        ((LOOKBEHIND_END) * 4 + 1)
#define LOOKBEHIND_END_t8_pb        ((LOOKBEHIND_END) * 4 + 2)
#define LOOKBEHIND_END_t8_p8        ((LOOKBEHIND_END) * 4 + 3)

/* 0x03 :   3
   SBOL - Match "" at beginning of line: /^/, /\A/ */
#define SBOL                        (LOOKBEHIND_END + 1)
#define SBOL_tb                     ((SBOL) * 2)
#define SBOL_t8                     ((SBOL) * 2 + 1)
#define SBOL_tb_pb                  ((SBOL) * 4)
#define SBOL_tb_p8                  ((SBOL) * 4 + 1)
#define SBOL_t8_pb                  ((SBOL) * 4 + 2)
#define SBOL_t8_p8                  ((SBOL) * 4 + 3)

/* 0x03 :   3
   BOL - type alias for SBOL */
#define BOL                         SBOL
#define BOL_tb                      ((BOL) * 2)
#define BOL_t8                      ((BOL) * 2 + 1)
#define BOL_tb_pb                   ((BOL) * 4)
#define BOL_tb_p8                   ((BOL) * 4 + 1)
#define BOL_t8_pb                   ((BOL) * 4 + 2)
#define BOL_t8_p8                   ((BOL) * 4 + 3)

/* 0x04 :   4
   MBOL - Same, assuming multiline: /^/m */
#define MBOL                        (SBOL + 1)
#define MBOL_tb                     ((MBOL) * 2)
#define MBOL_t8                     ((MBOL) * 2 + 1)
#define MBOL_tb_pb                  ((MBOL) * 4)
#define MBOL_tb_p8                  ((MBOL) * 4 + 1)
#define MBOL_t8_pb                  ((MBOL) * 4 + 2)
#define MBOL_t8_p8                  ((MBOL) * 4 + 3)

/* 0x05 :   5
   SEOL - Match "" at end of line: /$/ */
#define SEOL                        (MBOL + 1)
#define SEOL_tb                     ((SEOL) * 2)
#define SEOL_t8                     ((SEOL) * 2 + 1)
#define SEOL_tb_pb                  ((SEOL) * 4)
#define SEOL_tb_p8                  ((SEOL) * 4 + 1)
#define SEOL_t8_pb                  ((SEOL) * 4 + 2)
#define SEOL_t8_p8                  ((SEOL) * 4 + 3)

/* 0x05 :   5
   EOL - type alias for SEOL */
#define EOL                         SEOL
#define EOL_tb                      ((EOL) * 2)
#define EOL_t8                      ((EOL) * 2 + 1)
#define EOL_tb_pb                   ((EOL) * 4)
#define EOL_tb_p8                   ((EOL) * 4 + 1)
#define EOL_t8_pb                   ((EOL) * 4 + 2)
#define EOL_t8_p8                   ((EOL) * 4 + 3)

/* 0x06 :   6
   MEOL - Same, assuming multiline: /$/m */
#define MEOL                        (SEOL + 1)
#define MEOL_tb                     ((MEOL) * 2)
#define MEOL_t8                     ((MEOL) * 2 + 1)
#define MEOL_tb_pb                  ((MEOL) * 4)
#define MEOL_tb_p8                  ((MEOL) * 4 + 1)
#define MEOL_t8_pb                  ((MEOL) * 4 + 2)
#define MEOL_t8_p8                  ((MEOL) * 4 + 3)

/* 0x07 :   7
   EOS - Match "" at end of string: /\z/ */
#define EOS                         (MEOL + 1)
#define EOS_tb                      ((EOS) * 2)
#define EOS_t8                      ((EOS) * 2 + 1)
#define EOS_tb_pb                   ((EOS) * 4)
#define EOS_tb_p8                   ((EOS) * 4 + 1)
#define EOS_t8_pb                   ((EOS) * 4 + 2)
#define EOS_t8_p8                   ((EOS) * 4 + 3)

/* 0x08 :   8
   GPOS - Matches where last m//g left off. */
#define GPOS                        (EOS + 1)
#define GPOS_tb                     ((GPOS) * 2)
#define GPOS_t8                     ((GPOS) * 2 + 1)
#define GPOS_tb_pb                  ((GPOS) * 4)
#define GPOS_tb_p8                  ((GPOS) * 4 + 1)
#define GPOS_t8_pb                  ((GPOS) * 4 + 2)
#define GPOS_t8_p8                  ((GPOS) * 4 + 3)

/* 0x09 :   9
   BOUND - Like BOUNDA for non-utf8, otherwise like BOUNDU */
#define BOUND                       (GPOS + 1)
#define BOUND_tb                    ((BOUND) * 2)
#define BOUND_t8                    ((BOUND) * 2 + 1)
#define BOUND_tb_pb                 ((BOUND) * 4)
#define BOUND_tb_p8                 ((BOUND) * 4 + 1)
#define BOUND_t8_pb                 ((BOUND) * 4 + 2)
#define BOUND_t8_p8                 ((BOUND) * 4 + 3)

/* 0x0a :  10
   BOUNDL - Like BOUND/BOUNDU, but \w and \W are defined by current locale */
#define BOUNDL                      (BOUND + 1)
#define BOUNDL_tb                   ((BOUNDL) * 2)
#define BOUNDL_t8                   ((BOUNDL) * 2 + 1)
#define BOUNDL_tb_pb                ((BOUNDL) * 4)
#define BOUNDL_tb_p8                ((BOUNDL) * 4 + 1)
#define BOUNDL_t8_pb                ((BOUNDL) * 4 + 2)
#define BOUNDL_t8_p8                ((BOUNDL) * 4 + 3)

/* 0x0b :  11
   BOUNDU - Match "" at any boundary of a given type using /u rules. */
#define BOUNDU                      (BOUNDL + 1)
#define BOUNDU_tb                   ((BOUNDU) * 2)
#define BOUNDU_t8                   ((BOUNDU) * 2 + 1)
#define BOUNDU_tb_pb                ((BOUNDU) * 4)
#define BOUNDU_tb_p8                ((BOUNDU) * 4 + 1)
#define BOUNDU_t8_pb                ((BOUNDU) * 4 + 2)
#define BOUNDU_t8_p8                ((BOUNDU) * 4 + 3)

/* 0x0c :  12
   BOUNDA - Match "" at any boundary between \w\W or \W\w, where \w is
   [_a-zA-Z0-9] */
#define BOUNDA                      (BOUNDU + 1)
#define BOUNDA_tb                   ((BOUNDA) * 2)
#define BOUNDA_t8                   ((BOUNDA) * 2 + 1)
#define BOUNDA_tb_pb                ((BOUNDA) * 4)
#define BOUNDA_tb_p8                ((BOUNDA) * 4 + 1)
#define BOUNDA_t8_pb                ((BOUNDA) * 4 + 2)
#define BOUNDA_t8_p8                ((BOUNDA) * 4 + 3)

/* 0x0d :  13
   NBOUND - Like NBOUNDA for non-utf8, otherwise like BOUNDU */
#define NBOUND                      (BOUNDA + 1)
#define NBOUND_tb                   ((NBOUND) * 2)
#define NBOUND_t8                   ((NBOUND) * 2 + 1)
#define NBOUND_tb_pb                ((NBOUND) * 4)
#define NBOUND_tb_p8                ((NBOUND) * 4 + 1)
#define NBOUND_t8_pb                ((NBOUND) * 4 + 2)
#define NBOUND_t8_p8                ((NBOUND) * 4 + 3)

/* 0x0e :  14
   NBOUNDL - Like NBOUND/NBOUNDU, but \w and \W are defined by current locale */
#define NBOUNDL                     (NBOUND + 1)
#define NBOUNDL_tb                  ((NBOUNDL) * 2)
#define NBOUNDL_t8                  ((NBOUNDL) * 2 + 1)
#define NBOUNDL_tb_pb               ((NBOUNDL) * 4)
#define NBOUNDL_tb_p8               ((NBOUNDL) * 4 + 1)
#define NBOUNDL_t8_pb               ((NBOUNDL) * 4 + 2)
#define NBOUNDL_t8_p8               ((NBOUNDL) * 4 + 3)

/* 0x0f :  15
   NBOUNDU - Match "" at any non-boundary of a given type using /u rules. */
#define NBOUNDU                     (NBOUNDL + 1)
#define NBOUNDU_tb                  ((NBOUNDU) * 2)
#define NBOUNDU_t8                  ((NBOUNDU) * 2 + 1)
#define NBOUNDU_tb_pb               ((NBOUNDU) * 4)
#define NBOUNDU_tb_p8               ((NBOUNDU) * 4 + 1)
#define NBOUNDU_t8_pb               ((NBOUNDU) * 4 + 2)
#define NBOUNDU_t8_p8               ((NBOUNDU) * 4 + 3)

/* 0x10 :  16
   NBOUNDA - Match "" between any \w\w or \W\W, where \w is [_a-zA-Z0-9] */
#define NBOUNDA                     (NBOUNDU + 1)
#define NBOUNDA_tb                  ((NBOUNDA) * 2)
#define NBOUNDA_t8                  ((NBOUNDA) * 2 + 1)
#define NBOUNDA_tb_pb               ((NBOUNDA) * 4)
#define NBOUNDA_tb_p8               ((NBOUNDA) * 4 + 1)
#define NBOUNDA_t8_pb               ((NBOUNDA) * 4 + 2)
#define NBOUNDA_t8_p8               ((NBOUNDA) * 4 + 3)

/* 0x11 :  17
   REG_ANY - Match any one character (except newline). */
#define REG_ANY                     (NBOUNDA + 1)
#define REG_ANY_tb                  ((REG_ANY) * 2)
#define REG_ANY_t8                  ((REG_ANY) * 2 + 1)
#define REG_ANY_tb_pb               ((REG_ANY) * 4)
#define REG_ANY_tb_p8               ((REG_ANY) * 4 + 1)
#define REG_ANY_t8_pb               ((REG_ANY) * 4 + 2)
#define REG_ANY_t8_p8               ((REG_ANY) * 4 + 3)

/* 0x12 :  18
   SANY - Match any one character. */
#define SANY                        (REG_ANY + 1)
#define SANY_tb                     ((SANY) * 2)
#define SANY_t8                     ((SANY) * 2 + 1)
#define SANY_tb_pb                  ((SANY) * 4)
#define SANY_tb_p8                  ((SANY) * 4 + 1)
#define SANY_t8_pb                  ((SANY) * 4 + 2)
#define SANY_t8_p8                  ((SANY) * 4 + 3)

/* 0x13 :  19
   ANYOF - Match character in (or not in) this class, single char match only */
#define ANYOF                       (SANY + 1)
#define ANYOF_tb                    ((ANYOF) * 2)
#define ANYOF_t8                    ((ANYOF) * 2 + 1)
#define ANYOF_tb_pb                 ((ANYOF) * 4)
#define ANYOF_tb_p8                 ((ANYOF) * 4 + 1)
#define ANYOF_t8_pb                 ((ANYOF) * 4 + 2)
#define ANYOF_t8_p8                 ((ANYOF) * 4 + 3)

/* 0x14 :  20
   ANYOFD - Like ANYOF, but /d is in effect */
#define ANYOFD                      (ANYOF + 1)
#define ANYOFD_tb                   ((ANYOFD) * 2)
#define ANYOFD_t8                   ((ANYOFD) * 2 + 1)
#define ANYOFD_tb_pb                ((ANYOFD) * 4)
#define ANYOFD_tb_p8                ((ANYOFD) * 4 + 1)
#define ANYOFD_t8_pb                ((ANYOFD) * 4 + 2)
#define ANYOFD_t8_p8                ((ANYOFD) * 4 + 3)

/* 0x15 :  21
   ANYOFL - Like ANYOF, but /l is in effect */
#define ANYOFL                      (ANYOFD + 1)
#define ANYOFL_tb                   ((ANYOFL) * 2)
#define ANYOFL_t8                   ((ANYOFL) * 2 + 1)
#define ANYOFL_tb_pb                ((ANYOFL) * 4)
#define ANYOFL_tb_p8                ((ANYOFL) * 4 + 1)
#define ANYOFL_t8_pb                ((ANYOFL) * 4 + 2)
#define ANYOFL_t8_p8                ((ANYOFL) * 4 + 3)

/* 0x16 :  22
   ANYOFPOSIXL - Like ANYOFL, but matches [[:posix:]] classes */
#define ANYOFPOSIXL                 (ANYOFL + 1)
#define ANYOFPOSIXL_tb              ((ANYOFPOSIXL) * 2)
#define ANYOFPOSIXL_t8              ((ANYOFPOSIXL) * 2 + 1)
#define ANYOFPOSIXL_tb_pb           ((ANYOFPOSIXL) * 4)
#define ANYOFPOSIXL_tb_p8           ((ANYOFPOSIXL) * 4 + 1)
#define ANYOFPOSIXL_t8_pb           ((ANYOFPOSIXL) * 4 + 2)
#define ANYOFPOSIXL_t8_p8           ((ANYOFPOSIXL) * 4 + 3)

/* 0x17 :  23
   ANYOFH - Like ANYOF, but only has "High" matches, none in the bitmap; the
   flags field contains the lowest matchable UTF-8 start byte */
#define ANYOFH                      (ANYOFPOSIXL + 1)
#define ANYOFH_tb                   ((ANYOFH) * 2)
#define ANYOFH_t8                   ((ANYOFH) * 2 + 1)
#define ANYOFH_tb_pb                ((ANYOFH) * 4)
#define ANYOFH_tb_p8                ((ANYOFH) * 4 + 1)
#define ANYOFH_t8_pb                ((ANYOFH) * 4 + 2)
#define ANYOFH_t8_p8                ((ANYOFH) * 4 + 3)

/* 0x18 :  24
   ANYOFHb - Like ANYOFH, but all matches share the same UTF-8 start byte,
   given in the flags field */
#define ANYOFHb                     (ANYOFH + 1)
#define ANYOFHb_tb                  ((ANYOFHb) * 2)
#define ANYOFHb_t8                  ((ANYOFHb) * 2 + 1)
#define ANYOFHb_tb_pb               ((ANYOFHb) * 4)
#define ANYOFHb_tb_p8               ((ANYOFHb) * 4 + 1)
#define ANYOFHb_t8_pb               ((ANYOFHb) * 4 + 2)
#define ANYOFHb_t8_p8               ((ANYOFHb) * 4 + 3)

/* 0x19 :  25
   ANYOFHr - Like ANYOFH, but the flags field contains packed bounds for all
   matchable UTF-8 start bytes. */
#define ANYOFHr                     (ANYOFHb + 1)
#define ANYOFHr_tb                  ((ANYOFHr) * 2)
#define ANYOFHr_t8                  ((ANYOFHr) * 2 + 1)
#define ANYOFHr_tb_pb               ((ANYOFHr) * 4)
#define ANYOFHr_tb_p8               ((ANYOFHr) * 4 + 1)
#define ANYOFHr_t8_pb               ((ANYOFHr) * 4 + 2)
#define ANYOFHr_t8_p8               ((ANYOFHr) * 4 + 3)

/* 0x1a :  26
   ANYOFHs - Like ANYOFHb, but has a string field that gives the leading
   matchable UTF-8 bytes; flags field is len */
#define ANYOFHs                     (ANYOFHr + 1)
#define ANYOFHs_tb                  ((ANYOFHs) * 2)
#define ANYOFHs_t8                  ((ANYOFHs) * 2 + 1)
#define ANYOFHs_tb_pb               ((ANYOFHs) * 4)
#define ANYOFHs_tb_p8               ((ANYOFHs) * 4 + 1)
#define ANYOFHs_t8_pb               ((ANYOFHs) * 4 + 2)
#define ANYOFHs_t8_p8               ((ANYOFHs) * 4 + 3)

/* 0x1b :  27
   ANYOFR - Matches any character in the range given by its packed args: upper
   12 bits is the max delta from the base lower 20; the flags field contains
   the lowest matchable UTF-8 start byte */
#define ANYOFR                      (ANYOFHs + 1)
#define ANYOFR_tb                   ((ANYOFR) * 2)
#define ANYOFR_t8                   ((ANYOFR) * 2 + 1)
#define ANYOFR_tb_pb                ((ANYOFR) * 4)
#define ANYOFR_tb_p8                ((ANYOFR) * 4 + 1)
#define ANYOFR_t8_pb                ((ANYOFR) * 4 + 2)
#define ANYOFR_t8_p8                ((ANYOFR) * 4 + 3)

/* 0x1c :  28
   ANYOFRb - Like ANYOFR, but all matches share the same UTF-8 start byte,
   given in the flags field */
#define ANYOFRb                     (ANYOFR + 1)
#define ANYOFRb_tb                  ((ANYOFRb) * 2)
#define ANYOFRb_t8                  ((ANYOFRb) * 2 + 1)
#define ANYOFRb_tb_pb               ((ANYOFRb) * 4)
#define ANYOFRb_tb_p8               ((ANYOFRb) * 4 + 1)
#define ANYOFRb_t8_pb               ((ANYOFRb) * 4 + 2)
#define ANYOFRb_t8_p8               ((ANYOFRb) * 4 + 3)

/* 0x1d :  29
   ANYOFHbbm - Like ANYOFHb, but only for 2-byte UTF-8 characters; uses a
   bitmap to match the continuation byte */
#define ANYOFHbbm                   (ANYOFRb + 1)
#define ANYOFHbbm_tb                ((ANYOFHbbm) * 2)
#define ANYOFHbbm_t8                ((ANYOFHbbm) * 2 + 1)
#define ANYOFHbbm_tb_pb             ((ANYOFHbbm) * 4)
#define ANYOFHbbm_tb_p8             ((ANYOFHbbm) * 4 + 1)
#define ANYOFHbbm_t8_pb             ((ANYOFHbbm) * 4 + 2)
#define ANYOFHbbm_t8_p8             ((ANYOFHbbm) * 4 + 3)

/* 0x1e :  30
   ANYOFM - Like ANYOF, but matches an invariant byte as determined by the
   mask and arg */
#define ANYOFM                      (ANYOFHbbm + 1)
#define ANYOFM_tb                   ((ANYOFM) * 2)
#define ANYOFM_t8                   ((ANYOFM) * 2 + 1)
#define ANYOFM_tb_pb                ((ANYOFM) * 4)
#define ANYOFM_tb_p8                ((ANYOFM) * 4 + 1)
#define ANYOFM_t8_pb                ((ANYOFM) * 4 + 2)
#define ANYOFM_t8_p8                ((ANYOFM) * 4 + 3)

/* 0x1f :  31
   NANYOFM - complement of ANYOFM */
#define NANYOFM                     (ANYOFM + 1)
#define NANYOFM_tb                  ((NANYOFM) * 2)
#define NANYOFM_t8                  ((NANYOFM) * 2 + 1)
#define NANYOFM_tb_pb               ((NANYOFM) * 4)
#define NANYOFM_tb_p8               ((NANYOFM) * 4 + 1)
#define NANYOFM_t8_pb               ((NANYOFM) * 4 + 2)
#define NANYOFM_t8_p8               ((NANYOFM) * 4 + 3)

/* 0x20 :  32
   POSIXD - Some [[:class:]] under /d; the FLAGS field gives which one */
#define POSIXD                      (NANYOFM + 1)
#define POSIXD_tb                   ((POSIXD) * 2)
#define POSIXD_t8                   ((POSIXD) * 2 + 1)
#define POSIXD_tb_pb                ((POSIXD) * 4)
#define POSIXD_tb_p8                ((POSIXD) * 4 + 1)
#define POSIXD_t8_pb                ((POSIXD) * 4 + 2)
#define POSIXD_t8_p8                ((POSIXD) * 4 + 3)

/* 0x21 :  33
   POSIXL - Some [[:class:]] under /l; the FLAGS field gives which one */
#define POSIXL                      (POSIXD + 1)
#define POSIXL_tb                   ((POSIXL) * 2)
#define POSIXL_t8                   ((POSIXL) * 2 + 1)
#define POSIXL_tb_pb                ((POSIXL) * 4)
#define POSIXL_tb_p8                ((POSIXL) * 4 + 1)
#define POSIXL_t8_pb                ((POSIXL) * 4 + 2)
#define POSIXL_t8_p8                ((POSIXL) * 4 + 3)

/* 0x22 :  34
   POSIXU - Some [[:class:]] under /u; the FLAGS field gives which one */
#define POSIXU                      (POSIXL + 1)
#define POSIXU_tb                   ((POSIXU) * 2)
#define POSIXU_t8                   ((POSIXU) * 2 + 1)
#define POSIXU_tb_pb                ((POSIXU) * 4)
#define POSIXU_tb_p8                ((POSIXU) * 4 + 1)
#define POSIXU_t8_pb                ((POSIXU) * 4 + 2)
#define POSIXU_t8_p8                ((POSIXU) * 4 + 3)

/* 0x23 :  35
   POSIXA - Some [[:class:]] under /a; the FLAGS field gives which one */
#define POSIXA                      (POSIXU + 1)
#define POSIXA_tb                   ((POSIXA) * 2)
#define POSIXA_t8                   ((POSIXA) * 2 + 1)
#define POSIXA_tb_pb                ((POSIXA) * 4)
#define POSIXA_tb_p8                ((POSIXA) * 4 + 1)
#define POSIXA_t8_pb                ((POSIXA) * 4 + 2)
#define POSIXA_t8_p8                ((POSIXA) * 4 + 3)

/* 0x24 :  36
   NPOSIXD - complement of POSIXD, [[:^class:]] */
#define NPOSIXD                     (POSIXA + 1)
#define NPOSIXD_tb                  ((NPOSIXD) * 2)
#define NPOSIXD_t8                  ((NPOSIXD) * 2 + 1)
#define NPOSIXD_tb_pb               ((NPOSIXD) * 4)
#define NPOSIXD_tb_p8               ((NPOSIXD) * 4 + 1)
#define NPOSIXD_t8_pb               ((NPOSIXD) * 4 + 2)
#define NPOSIXD_t8_p8               ((NPOSIXD) * 4 + 3)

/* 0x25 :  37
   NPOSIXL - complement of POSIXL, [[:^class:]] */
#define NPOSIXL                     (NPOSIXD + 1)
#define NPOSIXL_tb                  ((NPOSIXL) * 2)
#define NPOSIXL_t8                  ((NPOSIXL) * 2 + 1)
#define NPOSIXL_tb_pb               ((NPOSIXL) * 4)
#define NPOSIXL_tb_p8               ((NPOSIXL) * 4 + 1)
#define NPOSIXL_t8_pb               ((NPOSIXL) * 4 + 2)
#define NPOSIXL_t8_p8               ((NPOSIXL) * 4 + 3)

/* 0x26 :  38
   NPOSIXU - complement of POSIXU, [[:^class:]] */
#define NPOSIXU                     (NPOSIXL + 1)
#define NPOSIXU_tb                  ((NPOSIXU) * 2)
#define NPOSIXU_t8                  ((NPOSIXU) * 2 + 1)
#define NPOSIXU_tb_pb               ((NPOSIXU) * 4)
#define NPOSIXU_tb_p8               ((NPOSIXU) * 4 + 1)
#define NPOSIXU_t8_pb               ((NPOSIXU) * 4 + 2)
#define NPOSIXU_t8_p8               ((NPOSIXU) * 4 + 3)

/* 0x27 :  39
   NPOSIXA - complement of POSIXA, [[:^class:]] */
#define NPOSIXA                     (NPOSIXU + 1)
#define NPOSIXA_tb                  ((NPOSIXA) * 2)
#define NPOSIXA_t8                  ((NPOSIXA) * 2 + 1)
#define NPOSIXA_tb_pb               ((NPOSIXA) * 4)
#define NPOSIXA_tb_p8               ((NPOSIXA) * 4 + 1)
#define NPOSIXA_t8_pb               ((NPOSIXA) * 4 + 2)
#define NPOSIXA_t8_p8               ((NPOSIXA) * 4 + 3)

/* 0x28 :  40
   CLUMP - Match any extended grapheme cluster sequence */
#define CLUMP                       (NPOSIXA + 1)
#define CLUMP_tb                    ((CLUMP) * 2)
#define CLUMP_t8                    ((CLUMP) * 2 + 1)
#define CLUMP_tb_pb                 ((CLUMP) * 4)
#define CLUMP_tb_p8                 ((CLUMP) * 4 + 1)
#define CLUMP_t8_pb                 ((CLUMP) * 4 + 2)
#define CLUMP_t8_p8                 ((CLUMP) * 4 + 3)

/* 0x29 :  41
   BRANCH - Match this alternative, or the next... */
#define BRANCH                      (CLUMP + 1)
#define BRANCH_tb                   ((BRANCH) * 2)
#define BRANCH_t8                   ((BRANCH) * 2 + 1)
#define BRANCH_tb_pb                ((BRANCH) * 4)
#define BRANCH_tb_p8                ((BRANCH) * 4 + 1)
#define BRANCH_t8_pb                ((BRANCH) * 4 + 2)
#define BRANCH_t8_p8                ((BRANCH) * 4 + 3)

/* 0x2a :  42
   EXACT - Match this string (flags field is the length). */
#define EXACT                       (BRANCH + 1)
#define EXACT_tb                    ((EXACT) * 2)
#define EXACT_t8                    ((EXACT) * 2 + 1)
#define EXACT_tb_pb                 ((EXACT) * 4)
#define EXACT_tb_p8                 ((EXACT) * 4 + 1)
#define EXACT_t8_pb                 ((EXACT) * 4 + 2)
#define EXACT_t8_p8                 ((EXACT) * 4 + 3)

/* 0x2b :  43
   LEXACT - Match this long string (preceded by length; flags unused). */
#define LEXACT                      (EXACT + 1)
#define LEXACT_tb                   ((LEXACT) * 2)
#define LEXACT_t8                   ((LEXACT) * 2 + 1)
#define LEXACT_tb_pb                ((LEXACT) * 4)
#define LEXACT_tb_p8                ((LEXACT) * 4 + 1)
#define LEXACT_t8_pb                ((LEXACT) * 4 + 2)
#define LEXACT_t8_p8                ((LEXACT) * 4 + 3)

/* 0x2c :  44
   EXACTL - Like EXACT, but /l is in effect (used so locale-related warnings
   can be checked for) */
#define EXACTL                      (LEXACT + 1)
#define EXACTL_tb                   ((EXACTL) * 2)
#define EXACTL_t8                   ((EXACTL) * 2 + 1)
#define EXACTL_tb_pb                ((EXACTL) * 4)
#define EXACTL_tb_p8                ((EXACTL) * 4 + 1)
#define EXACTL_t8_pb                ((EXACTL) * 4 + 2)
#define EXACTL_t8_p8                ((EXACTL) * 4 + 3)

/* 0x2d :  45
   EXACTF - Like EXACT, but match using /id rules; (string not UTF-8, ASCII
   folded; non-ASCII not) */
#define EXACTF                      (EXACTL + 1)
#define EXACTF_tb                   ((EXACTF) * 2)
#define EXACTF_t8                   ((EXACTF) * 2 + 1)
#define EXACTF_tb_pb                ((EXACTF) * 4)
#define EXACTF_tb_p8                ((EXACTF) * 4 + 1)
#define EXACTF_t8_pb                ((EXACTF) * 4 + 2)
#define EXACTF_t8_p8                ((EXACTF) * 4 + 3)

/* 0x2e :  46
   EXACTFL - Like EXACT, but match using /il rules; (string not likely to be
   folded) */
#define EXACTFL                     (EXACTF + 1)
#define EXACTFL_tb                  ((EXACTFL) * 2)
#define EXACTFL_t8                  ((EXACTFL) * 2 + 1)
#define EXACTFL_tb_pb               ((EXACTFL) * 4)
#define EXACTFL_tb_p8               ((EXACTFL) * 4 + 1)
#define EXACTFL_t8_pb               ((EXACTFL) * 4 + 2)
#define EXACTFL_t8_p8               ((EXACTFL) * 4 + 3)

/* 0x2f :  47
   EXACTFU - Like EXACT, but match using /iu rules; (string folded) */
#define EXACTFU                     (EXACTFL + 1)
#define EXACTFU_tb                  ((EXACTFU) * 2)
#define EXACTFU_t8                  ((EXACTFU) * 2 + 1)
#define EXACTFU_tb_pb               ((EXACTFU) * 4)
#define EXACTFU_tb_p8               ((EXACTFU) * 4 + 1)
#define EXACTFU_t8_pb               ((EXACTFU) * 4 + 2)
#define EXACTFU_t8_p8               ((EXACTFU) * 4 + 3)

/* 0x30 :  48
   EXACTFAA - Like EXACT, but match using /iaa rules; (string folded except
   MICRO in non-UTF8 patterns; doesn't contain SHARP S unless UTF-8; folded
   length <= unfolded) */
#define EXACTFAA                    (EXACTFU + 1)
#define EXACTFAA_tb                 ((EXACTFAA) * 2)
#define EXACTFAA_t8                 ((EXACTFAA) * 2 + 1)
#define EXACTFAA_tb_pb              ((EXACTFAA) * 4)
#define EXACTFAA_tb_p8              ((EXACTFAA) * 4 + 1)
#define EXACTFAA_t8_pb              ((EXACTFAA) * 4 + 2)
#define EXACTFAA_t8_p8              ((EXACTFAA) * 4 + 3)

/* 0x31 :  49
   EXACTFAA_NO_TRIE - Like EXACTFAA, (string not UTF-8, folded except: MICRO,
   SHARP S; folded length <= unfolded, not currently trie-able) */
#define EXACTFAA_NO_TRIE            (EXACTFAA + 1)
#define EXACTFAA_NO_TRIE_tb         ((EXACTFAA_NO_TRIE) * 2)
#define EXACTFAA_NO_TRIE_t8         ((EXACTFAA_NO_TRIE) * 2 + 1)
#define EXACTFAA_NO_TRIE_tb_pb      ((EXACTFAA_NO_TRIE) * 4)
#define EXACTFAA_NO_TRIE_tb_p8      ((EXACTFAA_NO_TRIE) * 4 + 1)
#define EXACTFAA_NO_TRIE_t8_pb      ((EXACTFAA_NO_TRIE) * 4 + 2)
#define EXACTFAA_NO_TRIE_t8_p8      ((EXACTFAA_NO_TRIE) * 4 + 3)

/* 0x32 :  50
   EXACTFUP - Like EXACT, but match using /iu rules; (string not UTF-8, folded
   except MICRO: hence Problematic) */
#define EXACTFUP                    (EXACTFAA_NO_TRIE + 1)
#define EXACTFUP_tb                 ((EXACTFUP) * 2)
#define EXACTFUP_t8                 ((EXACTFUP) * 2 + 1)
#define EXACTFUP_tb_pb              ((EXACTFUP) * 4)
#define EXACTFUP_tb_p8              ((EXACTFUP) * 4 + 1)
#define EXACTFUP_t8_pb              ((EXACTFUP) * 4 + 2)
#define EXACTFUP_t8_p8              ((EXACTFUP) * 4 + 3)

/* 0x33 :  51
   EXACTFLU8 - Like EXACTFU, but use /il, UTF-8, (string is folded, and
   everything in it is above 255 */
#define EXACTFLU8                   (EXACTFUP + 1)
#define EXACTFLU8_tb                ((EXACTFLU8) * 2)
#define EXACTFLU8_t8                ((EXACTFLU8) * 2 + 1)
#define EXACTFLU8_tb_pb             ((EXACTFLU8) * 4)
#define EXACTFLU8_tb_p8             ((EXACTFLU8) * 4 + 1)
#define EXACTFLU8_t8_pb             ((EXACTFLU8) * 4 + 2)
#define EXACTFLU8_t8_p8             ((EXACTFLU8) * 4 + 3)

/* 0x34 :  52
   EXACT_REQ8 - Like EXACT, but only UTF-8 encoded targets can match */
#define EXACT_REQ8                  (EXACTFLU8 + 1)
#define EXACT_REQ8_tb               ((EXACT_REQ8) * 2)
#define EXACT_REQ8_t8               ((EXACT_REQ8) * 2 + 1)
#define EXACT_REQ8_tb_pb            ((EXACT_REQ8) * 4)
#define EXACT_REQ8_tb_p8            ((EXACT_REQ8) * 4 + 1)
#define EXACT_REQ8_t8_pb            ((EXACT_REQ8) * 4 + 2)
#define EXACT_REQ8_t8_p8            ((EXACT_REQ8) * 4 + 3)

/* 0x35 :  53
   LEXACT_REQ8 - Like LEXACT, but only UTF-8 encoded targets can match */
#define LEXACT_REQ8                 (EXACT_REQ8 + 1)
#define LEXACT_REQ8_tb              ((LEXACT_REQ8) * 2)
#define LEXACT_REQ8_t8              ((LEXACT_REQ8) * 2 + 1)
#define LEXACT_REQ8_tb_pb           ((LEXACT_REQ8) * 4)
#define LEXACT_REQ8_tb_p8           ((LEXACT_REQ8) * 4 + 1)
#define LEXACT_REQ8_t8_pb           ((LEXACT_REQ8) * 4 + 2)
#define LEXACT_REQ8_t8_p8           ((LEXACT_REQ8) * 4 + 3)

/* 0x36 :  54
   EXACTFU_REQ8 - Like EXACTFU, but only UTF-8 encoded targets can match */
#define EXACTFU_REQ8                (LEXACT_REQ8 + 1)
#define EXACTFU_REQ8_tb             ((EXACTFU_REQ8) * 2)
#define EXACTFU_REQ8_t8             ((EXACTFU_REQ8) * 2 + 1)
#define EXACTFU_REQ8_tb_pb          ((EXACTFU_REQ8) * 4)
#define EXACTFU_REQ8_tb_p8          ((EXACTFU_REQ8) * 4 + 1)
#define EXACTFU_REQ8_t8_pb          ((EXACTFU_REQ8) * 4 + 2)
#define EXACTFU_REQ8_t8_p8          ((EXACTFU_REQ8) * 4 + 3)

/* 0x37 :  55
   EXACTFU_S_EDGE - /di rules, but nothing in it precludes /ui, except begins
   and/or ends with [Ss]; (string not UTF-8; compile-time only) */
#define EXACTFU_S_EDGE              (EXACTFU_REQ8 + 1)
#define EXACTFU_S_EDGE_tb           ((EXACTFU_S_EDGE) * 2)
#define EXACTFU_S_EDGE_t8           ((EXACTFU_S_EDGE) * 2 + 1)
#define EXACTFU_S_EDGE_tb_pb        ((EXACTFU_S_EDGE) * 4)
#define EXACTFU_S_EDGE_tb_p8        ((EXACTFU_S_EDGE) * 4 + 1)
#define EXACTFU_S_EDGE_t8_pb        ((EXACTFU_S_EDGE) * 4 + 2)
#define EXACTFU_S_EDGE_t8_p8        ((EXACTFU_S_EDGE) * 4 + 3)

/* 0x38 :  56
   LNBREAK - generic newline pattern */
#define LNBREAK                     (EXACTFU_S_EDGE + 1)
#define LNBREAK_tb                  ((LNBREAK) * 2)
#define LNBREAK_t8                  ((LNBREAK) * 2 + 1)
#define LNBREAK_tb_pb               ((LNBREAK) * 4)
#define LNBREAK_tb_p8               ((LNBREAK) * 4 + 1)
#define LNBREAK_t8_pb               ((LNBREAK) * 4 + 2)
#define LNBREAK_t8_p8               ((LNBREAK) * 4 + 3)

/* 0x39 :  57
   TRIE - Match many EXACT(F[ALU]?)? at once. flags==type */
#define TRIE                        (LNBREAK + 1)
#define TRIE_tb                     ((TRIE) * 2)
#define TRIE_t8                     ((TRIE) * 2 + 1)
#define TRIE_tb_pb                  ((TRIE) * 4)
#define TRIE_tb_p8                  ((TRIE) * 4 + 1)
#define TRIE_t8_pb                  ((TRIE) * 4 + 2)
#define TRIE_t8_p8                  ((TRIE) * 4 + 3)

/* 0x3a :  58
   TRIEC - Same as TRIE, but with embedded charclass data */
#define TRIEC                       (TRIE + 1)
#define TRIEC_tb                    ((TRIEC) * 2)
#define TRIEC_t8                    ((TRIEC) * 2 + 1)
#define TRIEC_tb_pb                 ((TRIEC) * 4)
#define TRIEC_tb_p8                 ((TRIEC) * 4 + 1)
#define TRIEC_t8_pb                 ((TRIEC) * 4 + 2)
#define TRIEC_t8_p8                 ((TRIEC) * 4 + 3)

/* 0x3b :  59
   AHOCORASICK - Aho Corasick stclass. flags==type */
#define AHOCORASICK                 (TRIEC + 1)
#define AHOCORASICK_tb              ((AHOCORASICK) * 2)
#define AHOCORASICK_t8              ((AHOCORASICK) * 2 + 1)
#define AHOCORASICK_tb_pb           ((AHOCORASICK) * 4)
#define AHOCORASICK_tb_p8           ((AHOCORASICK) * 4 + 1)
#define AHOCORASICK_t8_pb           ((AHOCORASICK) * 4 + 2)
#define AHOCORASICK_t8_p8           ((AHOCORASICK) * 4 + 3)

/* 0x3c :  60
   AHOCORASICKC - Same as AHOCORASICK, but with embedded charclass data */
#define AHOCORASICKC                (AHOCORASICK + 1)
#define AHOCORASICKC_tb             ((AHOCORASICKC) * 2)
#define AHOCORASICKC_t8             ((AHOCORASICKC) * 2 + 1)
#define AHOCORASICKC_tb_pb          ((AHOCORASICKC) * 4)
#define AHOCORASICKC_tb_p8          ((AHOCORASICKC) * 4 + 1)
#define AHOCORASICKC_t8_pb          ((AHOCORASICKC) * 4 + 2)
#define AHOCORASICKC_t8_p8          ((AHOCORASICKC) * 4 + 3)

/* 0x3d :  61
   LTRIE - Same as TRIE, but with longjump support */
#define LTRIE                       (AHOCORASICKC + 1)
#define LTRIE_tb                    ((LTRIE) * 2)
#define LTRIE_t8                    ((LTRIE) * 2 + 1)
#define LTRIE_tb_pb                 ((LTRIE) * 4)
#define LTRIE_tb_p8                 ((LTRIE) * 4 + 1)
#define LTRIE_t8_pb                 ((LTRIE) * 4 + 2)
#define LTRIE_t8_p8                 ((LTRIE) * 4 + 3)

/* 0x3e :  62
   LTRIEC - Same as TRIEC, but with longjump support */
#define LTRIEC                      (LTRIE + 1)
#define LTRIEC_tb                   ((LTRIEC) * 2)
#define LTRIEC_t8                   ((LTRIEC) * 2 + 1)
#define LTRIEC_tb_pb                ((LTRIEC) * 4)
#define LTRIEC_tb_p8                ((LTRIEC) * 4 + 1)
#define LTRIEC_t8_pb                ((LTRIEC) * 4 + 2)
#define LTRIEC_t8_p8                ((LTRIEC) * 4 + 3)

/* 0x3f :  63
   NOTHING - Match empty string. */
#define NOTHING                     (LTRIEC + 1)
#define NOTHING_tb                  ((NOTHING) * 2)
#define NOTHING_t8                  ((NOTHING) * 2 + 1)
#define NOTHING_tb_pb               ((NOTHING) * 4)
#define NOTHING_tb_p8               ((NOTHING) * 4 + 1)
#define NOTHING_t8_pb               ((NOTHING) * 4 + 2)
#define NOTHING_t8_p8               ((NOTHING) * 4 + 3)

/* 0x40 :  64
   TAIL - Match empty string. Can jump here from outside. */
#define TAIL                        (NOTHING + 1)
#define TAIL_tb                     ((TAIL) * 2)
#define TAIL_t8                     ((TAIL) * 2 + 1)
#define TAIL_tb_pb                  ((TAIL) * 4)
#define TAIL_tb_p8                  ((TAIL) * 4 + 1)
#define TAIL_t8_pb                  ((TAIL) * 4 + 2)
#define TAIL_t8_p8                  ((TAIL) * 4 + 3)

/* 0x41 :  65
   OPTIMIZED - This is not really a node, but an optimized away piece of a
   "long" node.  To simplify debugging output, we mark it as if it were a node */
#define OPTIMIZED                   (TAIL + 1)
#define OPTIMIZED_tb                ((OPTIMIZED) * 2)
#define OPTIMIZED_t8                ((OPTIMIZED) * 2 + 1)
#define OPTIMIZED_tb_pb             ((OPTIMIZED) * 4)
#define OPTIMIZED_tb_p8             ((OPTIMIZED) * 4 + 1)
#define OPTIMIZED_t8_pb             ((OPTIMIZED) * 4 + 2)
#define OPTIMIZED_t8_p8             ((OPTIMIZED) * 4 + 3)

/* 0x42 :  66
   STAR - Match this (simple) thing 0 or more times: /A{0,}B/ where A is width
   1 char */
#define STAR                        (OPTIMIZED + 1)
#define STAR_tb                     ((STAR) * 2)
#define STAR_t8                     ((STAR) * 2 + 1)
#define STAR_tb_pb                  ((STAR) * 4)
#define STAR_tb_p8                  ((STAR) * 4 + 1)
#define STAR_t8_pb                  ((STAR) * 4 + 2)
#define STAR_t8_p8                  ((STAR) * 4 + 3)

/* 0x43 :  67
   PLUS - Match this (simple) thing 1 or more times: /A{1,}B/ where A is width
   1 char */
#define PLUS                        (STAR + 1)
#define PLUS_tb                     ((PLUS) * 2)
#define PLUS_t8                     ((PLUS) * 2 + 1)
#define PLUS_tb_pb                  ((PLUS) * 4)
#define PLUS_tb_p8                  ((PLUS) * 4 + 1)
#define PLUS_t8_pb                  ((PLUS) * 4 + 2)
#define PLUS_t8_p8                  ((PLUS) * 4 + 3)

/* 0x44 :  68
   CURLY - Match this (simple) thing {n,m} times: /A{m,n}B/ where A is width 1
   char */
#define CURLY                       (PLUS + 1)
#define CURLY_tb                    ((CURLY) * 2)
#define CURLY_t8                    ((CURLY) * 2 + 1)
#define CURLY_tb_pb                 ((CURLY) * 4)
#define CURLY_tb_p8                 ((CURLY) * 4 + 1)
#define CURLY_t8_pb                 ((CURLY) * 4 + 2)
#define CURLY_t8_p8                 ((CURLY) * 4 + 3)

/* 0x45 :  69
   CURLYN - Capture next-after-this simple thing: /(A){m,n}B/ where A is width
   1 char */
#define CURLYN                      (CURLY + 1)
#define CURLYN_tb                   ((CURLYN) * 2)
#define CURLYN_t8                   ((CURLYN) * 2 + 1)
#define CURLYN_tb_pb                ((CURLYN) * 4)
#define CURLYN_tb_p8                ((CURLYN) * 4 + 1)
#define CURLYN_t8_pb                ((CURLYN) * 4 + 2)
#define CURLYN_t8_p8                ((CURLYN) * 4 + 3)

/* 0x46 :  70
   CURLYM - Capture this medium-complex thing {n,m} times: /(A){m,n}B/ where A
   is fixed-length */
#define CURLYM                      (CURLYN + 1)
#define CURLYM_tb                   ((CURLYM) * 2)
#define CURLYM_t8                   ((CURLYM) * 2 + 1)
#define CURLYM_tb_pb                ((CURLYM) * 4)
#define CURLYM_tb_p8                ((CURLYM) * 4 + 1)
#define CURLYM_t8_pb                ((CURLYM) * 4 + 2)
#define CURLYM_t8_p8                ((CURLYM) * 4 + 3)

/* 0x47 :  71
   CURLYX - Match/Capture this complex thing {n,m} times. */
#define CURLYX                      (CURLYM + 1)
#define CURLYX_tb                   ((CURLYX) * 2)
#define CURLYX_t8                   ((CURLYX) * 2 + 1)
#define CURLYX_tb_pb                ((CURLYX) * 4)
#define CURLYX_tb_p8                ((CURLYX) * 4 + 1)
#define CURLYX_t8_pb                ((CURLYX) * 4 + 2)
#define CURLYX_t8_p8                ((CURLYX) * 4 + 3)

/* 0x48 :  72
   WHILEM - Do curly processing and see if rest matches. */
#define WHILEM                      (CURLYX + 1)
#define WHILEM_tb                   ((WHILEM) * 2)
#define WHILEM_t8                   ((WHILEM) * 2 + 1)
#define WHILEM_tb_pb                ((WHILEM) * 4)
#define WHILEM_tb_p8                ((WHILEM) * 4 + 1)
#define WHILEM_t8_pb                ((WHILEM) * 4 + 2)
#define WHILEM_t8_p8                ((WHILEM) * 4 + 3)

/* 0x49 :  73
   OPEN - Mark this point in input as start of #n. */
#define OPEN                        (WHILEM + 1)
#define OPEN_tb                     ((OPEN) * 2)
#define OPEN_t8                     ((OPEN) * 2 + 1)
#define OPEN_tb_pb                  ((OPEN) * 4)
#define OPEN_tb_p8                  ((OPEN) * 4 + 1)
#define OPEN_t8_pb                  ((OPEN) * 4 + 2)
#define OPEN_t8_p8                  ((OPEN) * 4 + 3)

/* 0x4a :  74
   CLOSE - Close corresponding OPEN of #n. */
#define CLOSE                       (OPEN + 1)
#define CLOSE_tb                    ((CLOSE) * 2)
#define CLOSE_t8                    ((CLOSE) * 2 + 1)
#define CLOSE_tb_pb                 ((CLOSE) * 4)
#define CLOSE_tb_p8                 ((CLOSE) * 4 + 1)
#define CLOSE_t8_pb                 ((CLOSE) * 4 + 2)
#define CLOSE_t8_p8                 ((CLOSE) * 4 + 3)

/* 0x4b :  75
   SROPEN - Start a script run */
#define SROPEN                      (CLOSE + 1)
#define SROPEN_tb                   ((SROPEN) * 2)
#define SROPEN_t8                   ((SROPEN) * 2 + 1)
#define SROPEN_tb_pb                ((SROPEN) * 4)
#define SROPEN_tb_p8                ((SROPEN) * 4 + 1)
#define SROPEN_t8_pb                ((SROPEN) * 4 + 2)
#define SROPEN_t8_p8                ((SROPEN) * 4 + 3)

/* 0x4c :  76
   SRCLOSE -  */
#define SRCLOSE                     (SROPEN + 1)
#define SRCLOSE_tb                  ((SRCLOSE) * 2)
#define SRCLOSE_t8                  ((SRCLOSE) * 2 + 1)
#define SRCLOSE_tb_pb               ((SRCLOSE) * 4)
#define SRCLOSE_tb_p8               ((SRCLOSE) * 4 + 1)
#define SRCLOSE_t8_pb               ((SRCLOSE) * 4 + 2)
#define SRCLOSE_t8_p8               ((SRCLOSE) * 4 + 3)

/* 0x4d :  77
   REF - Match some already matched string */
#define REF                         (SRCLOSE + 1)
#define REF_tb                      ((REF) * 2)
#define REF_t8                      ((REF) * 2 + 1)
#define REF_tb_pb                   ((REF) * 4)
#define REF_tb_p8                   ((REF) * 4 + 1)
#define REF_t8_pb                   ((REF) * 4 + 2)
#define REF_t8_p8                   ((REF) * 4 + 3)

/* 0x4e :  78
   REFF - Match already matched string, using /di rules. */
#define REFF                        (REF + 1)
#define REFF_tb                     ((REFF) * 2)
#define REFF_t8                     ((REFF) * 2 + 1)
#define REFF_tb_pb                  ((REFF) * 4)
#define REFF_tb_p8                  ((REFF) * 4 + 1)
#define REFF_t8_pb                  ((REFF) * 4 + 2)
#define REFF_t8_p8                  ((REFF) * 4 + 3)

/* 0x4f :  79
   REFFL - Match already matched string, using /li rules. */
#define REFFL                       (REFF + 1)
#define REFFL_tb                    ((REFFL) * 2)
#define REFFL_t8                    ((REFFL) * 2 + 1)
#define REFFL_tb_pb                 ((REFFL) * 4)
#define REFFL_tb_p8                 ((REFFL) * 4 + 1)
#define REFFL_t8_pb                 ((REFFL) * 4 + 2)
#define REFFL_t8_p8                 ((REFFL) * 4 + 3)

/* 0x50 :  80
   REFFU - Match already matched string, using /ui. */
#define REFFU                       (REFFL + 1)
#define REFFU_tb                    ((REFFU) * 2)
#define REFFU_t8                    ((REFFU) * 2 + 1)
#define REFFU_tb_pb                 ((REFFU) * 4)
#define REFFU_tb_p8                 ((REFFU) * 4 + 1)
#define REFFU_t8_pb                 ((REFFU) * 4 + 2)
#define REFFU_t8_p8                 ((REFFU) * 4 + 3)

/* 0x51 :  81
   REFFA - Match already matched string, using /aai rules. */
#define REFFA                       (REFFU + 1)
#define REFFA_tb                    ((REFFA) * 2)
#define REFFA_t8                    ((REFFA) * 2 + 1)
#define REFFA_tb_pb                 ((REFFA) * 4)
#define REFFA_tb_p8                 ((REFFA) * 4 + 1)
#define REFFA_t8_pb                 ((REFFA) * 4 + 2)
#define REFFA_t8_p8                 ((REFFA) * 4 + 3)

/* 0x52 :  82
   REFN - Match some already matched string */
#define REFN                        (REFFA + 1)
#define REFN_tb                     ((REFN) * 2)
#define REFN_t8                     ((REFN) * 2 + 1)
#define REFN_tb_pb                  ((REFN) * 4)
#define REFN_tb_p8                  ((REFN) * 4 + 1)
#define REFN_t8_pb                  ((REFN) * 4 + 2)
#define REFN_t8_p8                  ((REFN) * 4 + 3)

/* 0x53 :  83
   REFFN - Match already matched string, using /di rules. */
#define REFFN                       (REFN + 1)
#define REFFN_tb                    ((REFFN) * 2)
#define REFFN_t8                    ((REFFN) * 2 + 1)
#define REFFN_tb_pb                 ((REFFN) * 4)
#define REFFN_tb_p8                 ((REFFN) * 4 + 1)
#define REFFN_t8_pb                 ((REFFN) * 4 + 2)
#define REFFN_t8_p8                 ((REFFN) * 4 + 3)

/* 0x54 :  84
   REFFLN - Match already matched string, using /li rules. */
#define REFFLN                      (REFFN + 1)
#define REFFLN_tb                   ((REFFLN) * 2)
#define REFFLN_t8                   ((REFFLN) * 2 + 1)
#define REFFLN_tb_pb                ((REFFLN) * 4)
#define REFFLN_tb_p8                ((REFFLN) * 4 + 1)
#define REFFLN_t8_pb                ((REFFLN) * 4 + 2)
#define REFFLN_t8_p8                ((REFFLN) * 4 + 3)

/* 0x55 :  85
   REFFUN - Match already matched string, using /ui rules. */
#define REFFUN                      (REFFLN + 1)
#define REFFUN_tb                   ((REFFUN) * 2)
#define REFFUN_t8                   ((REFFUN) * 2 + 1)
#define REFFUN_tb_pb                ((REFFUN) * 4)
#define REFFUN_tb_p8                ((REFFUN) * 4 + 1)
#define REFFUN_t8_pb                ((REFFUN) * 4 + 2)
#define REFFUN_t8_p8                ((REFFUN) * 4 + 3)

/* 0x56 :  86
   REFFAN - Match already matched string, using /aai rules. */
#define REFFAN                      (REFFUN + 1)
#define REFFAN_tb                   ((REFFAN) * 2)
#define REFFAN_t8                   ((REFFAN) * 2 + 1)
#define REFFAN_tb_pb                ((REFFAN) * 4)
#define REFFAN_tb_p8                ((REFFAN) * 4 + 1)
#define REFFAN_t8_pb                ((REFFAN) * 4 + 2)
#define REFFAN_t8_p8                ((REFFAN) * 4 + 3)

/* 0x57 :  87
   BRANCHJ - BRANCH with long offset. */
#define BRANCHJ                     (REFFAN + 1)
#define BRANCHJ_tb                  ((BRANCHJ) * 2)
#define BRANCHJ_t8                  ((BRANCHJ) * 2 + 1)
#define BRANCHJ_tb_pb               ((BRANCHJ) * 4)
#define BRANCHJ_tb_p8               ((BRANCHJ) * 4 + 1)
#define BRANCHJ_t8_pb               ((BRANCHJ) * 4 + 2)
#define BRANCHJ_t8_p8               ((BRANCHJ) * 4 + 3)

/* 0x58 :  88
   IFMATCH - Succeeds if the following matches; non-zero flags "f", next_off
   "o" means lookbehind assertion starting "f..(f-o)" characters before
   current */
#define IFMATCH                     (BRANCHJ + 1)
#define IFMATCH_tb                  ((IFMATCH) * 2)
#define IFMATCH_t8                  ((IFMATCH) * 2 + 1)
#define IFMATCH_tb_pb               ((IFMATCH) * 4)
#define IFMATCH_tb_p8               ((IFMATCH) * 4 + 1)
#define IFMATCH_t8_pb               ((IFMATCH) * 4 + 2)
#define IFMATCH_t8_p8               ((IFMATCH) * 4 + 3)

/* 0x59 :  89
   UNLESSM - Fails if the following matches; non-zero flags "f", next_off "o"
   means lookbehind assertion starting "f..(f-o)" characters before current */
#define UNLESSM                     (IFMATCH + 1)
#define UNLESSM_tb                  ((UNLESSM) * 2)
#define UNLESSM_t8                  ((UNLESSM) * 2 + 1)
#define UNLESSM_tb_pb               ((UNLESSM) * 4)
#define UNLESSM_tb_p8               ((UNLESSM) * 4 + 1)
#define UNLESSM_t8_pb               ((UNLESSM) * 4 + 2)
#define UNLESSM_t8_p8               ((UNLESSM) * 4 + 3)

/* 0x5a :  90
   SUSPEND - "Independent" sub-RE. */
#define SUSPEND                     (UNLESSM + 1)
#define SUSPEND_tb                  ((SUSPEND) * 2)
#define SUSPEND_t8                  ((SUSPEND) * 2 + 1)
#define SUSPEND_tb_pb               ((SUSPEND) * 4)
#define SUSPEND_tb_p8               ((SUSPEND) * 4 + 1)
#define SUSPEND_t8_pb               ((SUSPEND) * 4 + 2)
#define SUSPEND_t8_p8               ((SUSPEND) * 4 + 3)

/* 0x5b :  91
   IFTHEN - Switch, should be preceded by switcher. */
#define IFTHEN                      (SUSPEND + 1)
#define IFTHEN_tb                   ((IFTHEN) * 2)
#define IFTHEN_t8                   ((IFTHEN) * 2 + 1)
#define IFTHEN_tb_pb                ((IFTHEN) * 4)
#define IFTHEN_tb_p8                ((IFTHEN) * 4 + 1)
#define IFTHEN_t8_pb                ((IFTHEN) * 4 + 2)
#define IFTHEN_t8_p8                ((IFTHEN) * 4 + 3)

/* 0x5c :  92
   RENUM - Group with independently numbered parens. Not used yet. */
#define RENUM                       (IFTHEN + 1)
#define RENUM_tb                    ((RENUM) * 2)
#define RENUM_t8                    ((RENUM) * 2 + 1)
#define RENUM_tb_pb                 ((RENUM) * 4)
#define RENUM_tb_p8                 ((RENUM) * 4 + 1)
#define RENUM_t8_pb                 ((RENUM) * 4 + 2)
#define RENUM_t8_p8                 ((RENUM) * 4 + 3)

/* 0x5d :  93
   LONGJMP - Jump far away. */
#define LONGJMP                     (RENUM + 1)
#define LONGJMP_tb                  ((LONGJMP) * 2)
#define LONGJMP_t8                  ((LONGJMP) * 2 + 1)
#define LONGJMP_tb_pb               ((LONGJMP) * 4)
#define LONGJMP_tb_p8               ((LONGJMP) * 4 + 1)
#define LONGJMP_t8_pb               ((LONGJMP) * 4 + 2)
#define LONGJMP_t8_p8               ((LONGJMP) * 4 + 3)

/* 0x5e :  94
   MINMOD - Next operator is not greedy. */
#define MINMOD                      (LONGJMP + 1)
#define MINMOD_tb                   ((MINMOD) * 2)
#define MINMOD_t8                   ((MINMOD) * 2 + 1)
#define MINMOD_tb_pb                ((MINMOD) * 4)
#define MINMOD_tb_p8                ((MINMOD) * 4 + 1)
#define MINMOD_t8_pb                ((MINMOD) * 4 + 2)
#define MINMOD_t8_p8                ((MINMOD) * 4 + 3)

/* 0x5f :  95
   LOGICAL - Next opcode should set the flag only. */
#define LOGICAL                     (MINMOD + 1)
#define LOGICAL_tb                  ((LOGICAL) * 2)
#define LOGICAL_t8                  ((LOGICAL) * 2 + 1)
#define LOGICAL_tb_pb               ((LOGICAL) * 4)
#define LOGICAL_tb_p8               ((LOGICAL) * 4 + 1)
#define LOGICAL_t8_pb               ((LOGICAL) * 4 + 2)
#define LOGICAL_t8_p8               ((LOGICAL) * 4 + 3)

/* 0x60 :  96
   EVAL - Execute some Perl code. Used by other opcodes in some cases */
#define EVAL                        (LOGICAL + 1)
#define EVAL_tb                     ((EVAL) * 2)
#define EVAL_t8                     ((EVAL) * 2 + 1)
#define EVAL_tb_pb                  ((EVAL) * 4)
#define EVAL_tb_p8                  ((EVAL) * 4 + 1)
#define EVAL_t8_pb                  ((EVAL) * 4 + 2)
#define EVAL_t8_p8                  ((EVAL) * 4 + 3)

/* 0x61 :  97
   GOSUB - recurse to paren arg1 at (signed) ofs arg2 */
#define GOSUB                       (EVAL + 1)
#define GOSUB_tb                    ((GOSUB) * 2)
#define GOSUB_t8                    ((GOSUB) * 2 + 1)
#define GOSUB_tb_pb                 ((GOSUB) * 4)
#define GOSUB_tb_p8                 ((GOSUB) * 4 + 1)
#define GOSUB_t8_pb                 ((GOSUB) * 4 + 2)
#define GOSUB_t8_p8                 ((GOSUB) * 4 + 3)

/* 0x62 :  98
   GROUPP - Whether the group matched. */
#define GROUPP                      (GOSUB + 1)
#define GROUPP_tb                   ((GROUPP) * 2)
#define GROUPP_t8                   ((GROUPP) * 2 + 1)
#define GROUPP_tb_pb                ((GROUPP) * 4)
#define GROUPP_tb_p8                ((GROUPP) * 4 + 1)
#define GROUPP_t8_pb                ((GROUPP) * 4 + 2)
#define GROUPP_t8_p8                ((GROUPP) * 4 + 3)

/* 0x63 :  99
   GROUPPN - Whether the named group matched. */
#define GROUPPN                     (GROUPP + 1)
#define GROUPPN_tb                  ((GROUPPN) * 2)
#define GROUPPN_t8                  ((GROUPPN) * 2 + 1)
#define GROUPPN_tb_pb               ((GROUPPN) * 4)
#define GROUPPN_tb_p8               ((GROUPPN) * 4 + 1)
#define GROUPPN_t8_pb               ((GROUPPN) * 4 + 2)
#define GROUPPN_t8_p8               ((GROUPPN) * 4 + 3)

/* 0x64 : 100
   INSUBP - Whether we are in a specific recurse. */
#define INSUBP                      (GROUPPN + 1)
#define INSUBP_tb                   ((INSUBP) * 2)
#define INSUBP_t8                   ((INSUBP) * 2 + 1)
#define INSUBP_tb_pb                ((INSUBP) * 4)
#define INSUBP_tb_p8                ((INSUBP) * 4 + 1)
#define INSUBP_t8_pb                ((INSUBP) * 4 + 2)
#define INSUBP_t8_p8                ((INSUBP) * 4 + 3)

/* 0x65 : 101
   DEFINEP - Define regex subroutines. Contents never executed directly,
   disallows 'no' branch in conditional. */
#define DEFINEP                     (INSUBP + 1)
#define DEFINEP_tb                  ((DEFINEP) * 2)
#define DEFINEP_t8                  ((DEFINEP) * 2 + 1)
#define DEFINEP_tb_pb               ((DEFINEP) * 4)
#define DEFINEP_tb_p8               ((DEFINEP) * 4 + 1)
#define DEFINEP_t8_pb               ((DEFINEP) * 4 + 2)
#define DEFINEP_t8_p8               ((DEFINEP) * 4 + 3)

/* 0x66 : 102
   ENDLIKE - Used only for the type field of verbs */
#define ENDLIKE                     (DEFINEP + 1)
#define ENDLIKE_tb                  ((ENDLIKE) * 2)
#define ENDLIKE_t8                  ((ENDLIKE) * 2 + 1)
#define ENDLIKE_tb_pb               ((ENDLIKE) * 4)
#define ENDLIKE_tb_p8               ((ENDLIKE) * 4 + 1)
#define ENDLIKE_t8_pb               ((ENDLIKE) * 4 + 2)
#define ENDLIKE_t8_p8               ((ENDLIKE) * 4 + 3)

/* 0x67 : 103
   OPFAIL - Same as (?!), but with verb arg */
#define OPFAIL                      (ENDLIKE + 1)
#define OPFAIL_tb                   ((OPFAIL) * 2)
#define OPFAIL_t8                   ((OPFAIL) * 2 + 1)
#define OPFAIL_tb_pb                ((OPFAIL) * 4)
#define OPFAIL_tb_p8                ((OPFAIL) * 4 + 1)
#define OPFAIL_t8_pb                ((OPFAIL) * 4 + 2)
#define OPFAIL_t8_p8                ((OPFAIL) * 4 + 3)

/* 0x68 : 104
   ACCEPT - Accepts the current matched string, with verbar */
#define ACCEPT                      (OPFAIL + 1)
#define ACCEPT_tb                   ((ACCEPT) * 2)
#define ACCEPT_t8                   ((ACCEPT) * 2 + 1)
#define ACCEPT_tb_pb                ((ACCEPT) * 4)
#define ACCEPT_tb_p8                ((ACCEPT) * 4 + 1)
#define ACCEPT_t8_pb                ((ACCEPT) * 4 + 2)
#define ACCEPT_t8_p8                ((ACCEPT) * 4 + 3)

/* 0x69 : 105
   VERB - Used only for the type field of verbs */
#define VERB                        (ACCEPT + 1)
#define VERB_tb                     ((VERB) * 2)
#define VERB_t8                     ((VERB) * 2 + 1)
#define VERB_tb_pb                  ((VERB) * 4)
#define VERB_tb_p8                  ((VERB) * 4 + 1)
#define VERB_t8_pb                  ((VERB) * 4 + 2)
#define VERB_t8_p8                  ((VERB) * 4 + 3)

/* 0x6a : 106
   PRUNE - Pattern fails at this startpoint if no-backtracking through this */
#define PRUNE                       (VERB + 1)
#define PRUNE_tb                    ((PRUNE) * 2)
#define PRUNE_t8                    ((PRUNE) * 2 + 1)
#define PRUNE_tb_pb                 ((PRUNE) * 4)
#define PRUNE_tb_p8                 ((PRUNE) * 4 + 1)
#define PRUNE_t8_pb                 ((PRUNE) * 4 + 2)
#define PRUNE_t8_p8                 ((PRUNE) * 4 + 3)

/* 0x6b : 107
   MARKPOINT - Push the current location for rollback by cut. */
#define MARKPOINT                   (PRUNE + 1)
#define MARKPOINT_tb                ((MARKPOINT) * 2)
#define MARKPOINT_t8                ((MARKPOINT) * 2 + 1)
#define MARKPOINT_tb_pb             ((MARKPOINT) * 4)
#define MARKPOINT_tb_p8             ((MARKPOINT) * 4 + 1)
#define MARKPOINT_t8_pb             ((MARKPOINT) * 4 + 2)
#define MARKPOINT_t8_p8             ((MARKPOINT) * 4 + 3)

/* 0x6c : 108
   SKIP - On failure skip forward (to the mark) before retrying */
#define SKIP                        (MARKPOINT + 1)
#define SKIP_tb                     ((SKIP) * 2)
#define SKIP_t8                     ((SKIP) * 2 + 1)
#define SKIP_tb_pb                  ((SKIP) * 4)
#define SKIP_tb_p8                  ((SKIP) * 4 + 1)
#define SKIP_t8_pb                  ((SKIP) * 4 + 2)
#define SKIP_t8_p8                  ((SKIP) * 4 + 3)

/* 0x6d : 109
   COMMIT - Pattern fails outright if backtracking through this */
#define COMMIT                      (SKIP + 1)
#define COMMIT_tb                   ((COMMIT) * 2)
#define COMMIT_t8                   ((COMMIT) * 2 + 1)
#define COMMIT_tb_pb                ((COMMIT) * 4)
#define COMMIT_tb_p8                ((COMMIT) * 4 + 1)
#define COMMIT_t8_pb                ((COMMIT) * 4 + 2)
#define COMMIT_t8_p8                ((COMMIT) * 4 + 3)

/* 0x6e : 110
   CUTGROUP - On failure go to the next alternation in the group */
#define CUTGROUP                    (COMMIT + 1)
#define CUTGROUP_tb                 ((CUTGROUP) * 2)
#define CUTGROUP_t8                 ((CUTGROUP) * 2 + 1)
#define CUTGROUP_tb_pb              ((CUTGROUP) * 4)
#define CUTGROUP_tb_p8              ((CUTGROUP) * 4 + 1)
#define CUTGROUP_t8_pb              ((CUTGROUP) * 4 + 2)
#define CUTGROUP_t8_p8              ((CUTGROUP) * 4 + 3)

/* 0x6f : 111
   KEEPS - $& begins here. */
#define KEEPS                       (CUTGROUP + 1)
#define KEEPS_tb                    ((KEEPS) * 2)
#define KEEPS_t8                    ((KEEPS) * 2 + 1)
#define KEEPS_tb_pb                 ((KEEPS) * 4)
#define KEEPS_tb_p8                 ((KEEPS) * 4 + 1)
#define KEEPS_t8_pb                 ((KEEPS) * 4 + 2)
#define KEEPS_t8_p8                 ((KEEPS) * 4 + 3)

/* 0x70 : 112
   PSEUDO - Pseudo opcode for internal use. */
#define PSEUDO                      (KEEPS + 1)
#define PSEUDO_tb                   ((PSEUDO) * 2)
#define PSEUDO_t8                   ((PSEUDO) * 2 + 1)
#define PSEUDO_tb_pb                ((PSEUDO) * 4)
#define PSEUDO_tb_p8                ((PSEUDO) * 4 + 1)
#define PSEUDO_t8_pb                ((PSEUDO) * 4 + 2)
#define PSEUDO_t8_p8                ((PSEUDO) * 4 + 3)

/* 0x71 : 113
   REGEX_SET - Regex set, temporary node used in pre-optimization compilation */
#define REGEX_SET                   (PSEUDO + 1)
#define REGEX_SET_tb                ((REGEX_SET) * 2)
#define REGEX_SET_t8                ((REGEX_SET) * 2 + 1)
#define REGEX_SET_tb_pb             ((REGEX_SET) * 4)
#define REGEX_SET_tb_p8             ((REGEX_SET) * 4 + 1)
#define REGEX_SET_t8_pb             ((REGEX_SET) * 4 + 2)
#define REGEX_SET_t8_p8             ((REGEX_SET) * 4 + 3)

	/* ------------ States ------------- */
/* 0x72 : 114
   TRIE_next - state for TRIE */
#define TRIE_next                   (REGNODE_MAX + 1)
#define TRIE_next_tb                ((TRIE_next) * 2)
#define TRIE_next_t8                ((TRIE_next) * 2 + 1)
#define TRIE_next_tb_pb             ((TRIE_next) * 4)
#define TRIE_next_tb_p8             ((TRIE_next) * 4 + 1)
#define TRIE_next_t8_pb             ((TRIE_next) * 4 + 2)
#define TRIE_next_t8_p8             ((TRIE_next) * 4 + 3)

/* 0x73 : 115
   TRIE_next_fail - state for TRIE */
#define TRIE_next_fail              (TRIE_next + 1)
#define TRIE_next_fail_tb           ((TRIE_next_fail) * 2)
#define TRIE_next_fail_t8           ((TRIE_next_fail) * 2 + 1)
#define TRIE_next_fail_tb_pb        ((TRIE_next_fail) * 4)
#define TRIE_next_fail_tb_p8        ((TRIE_next_fail) * 4 + 1)
#define TRIE_next_fail_t8_pb        ((TRIE_next_fail) * 4 + 2)
#define TRIE_next_fail_t8_p8        ((TRIE_next_fail) * 4 + 3)

/* 0x74 : 116
   EVAL_B - state for EVAL */
#define EVAL_B                      (TRIE_next_fail + 1)
#define EVAL_B_tb                   ((EVAL_B) * 2)
#define EVAL_B_t8                   ((EVAL_B) * 2 + 1)
#define EVAL_B_tb_pb                ((EVAL_B) * 4)
#define EVAL_B_tb_p8                ((EVAL_B) * 4 + 1)
#define EVAL_B_t8_pb                ((EVAL_B) * 4 + 2)
#define EVAL_B_t8_p8                ((EVAL_B) * 4 + 3)

/* 0x75 : 117
   EVAL_B_fail - state for EVAL */
#define EVAL_B_fail                 (EVAL_B + 1)
#define EVAL_B_fail_tb              ((EVAL_B_fail) * 2)
#define EVAL_B_fail_t8              ((EVAL_B_fail) * 2 + 1)
#define EVAL_B_fail_tb_pb           ((EVAL_B_fail) * 4)
#define EVAL_B_fail_tb_p8           ((EVAL_B_fail) * 4 + 1)
#define EVAL_B_fail_t8_pb           ((EVAL_B_fail) * 4 + 2)
#define EVAL_B_fail_t8_p8           ((EVAL_B_fail) * 4 + 3)

/* 0x76 : 118
   EVAL_postponed_A - state for EVAL */
#define EVAL_postponed_A            (EVAL_B_fail + 1)
#define EVAL_postponed_A_tb         ((EVAL_postponed_A) * 2)
#define EVAL_postponed_A_t8         ((EVAL_postponed_A) * 2 + 1)
#define EVAL_postponed_A_tb_pb      ((EVAL_postponed_A) * 4)
#define EVAL_postponed_A_tb_p8      ((EVAL_postponed_A) * 4 + 1)
#define EVAL_postponed_A_t8_pb      ((EVAL_postponed_A) * 4 + 2)
#define EVAL_postponed_A_t8_p8      ((EVAL_postponed_A) * 4 + 3)

/* 0x77 : 119
   EVAL_postponed_A_fail - state for EVAL */
#define EVAL_postponed_A_fail       (EVAL_postponed_A + 1)
#define EVAL_postponed_A_fail_tb    ((EVAL_postponed_A_fail) * 2)
#define EVAL_postponed_A_fail_t8    ((EVAL_postponed_A_fail) * 2 + 1)
#define EVAL_postponed_A_fail_tb_pb ((EVAL_postponed_A_fail) * 4)
#define EVAL_postponed_A_fail_tb_p8 ((EVAL_postponed_A_fail) * 4 + 1)
#define EVAL_postponed_A_fail_t8_pb ((EVAL_postponed_A_fail) * 4 + 2)
#define EVAL_postponed_A_fail_t8_p8 ((EVAL_postponed_A_fail) * 4 + 3)

/* 0x78 : 120
   EVAL_postponed_B - state for EVAL */
#define EVAL_postponed_B            (EVAL_postponed_A_fail + 1)
#define EVAL_postponed_B_tb         ((EVAL_postponed_B) * 2)
#define EVAL_postponed_B_t8         ((EVAL_postponed_B) * 2 + 1)
#define EVAL_postponed_B_tb_pb      ((EVAL_postponed_B) * 4)
#define EVAL_postponed_B_tb_p8      ((EVAL_postponed_B) * 4 + 1)
#define EVAL_postponed_B_t8_pb      ((EVAL_postponed_B) * 4 + 2)
#define EVAL_postponed_B_t8_p8      ((EVAL_postponed_B) * 4 + 3)

/* 0x79 : 121
   EVAL_postponed_B_fail - state for EVAL */
#define EVAL_postponed_B_fail       (EVAL_postponed_B + 1)
#define EVAL_postponed_B_fail_tb    ((EVAL_postponed_B_fail) * 2)
#define EVAL_postponed_B_fail_t8    ((EVAL_postponed_B_fail) * 2 + 1)
#define EVAL_postponed_B_fail_tb_pb ((EVAL_postponed_B_fail) * 4)
#define EVAL_postponed_B_fail_tb_p8 ((EVAL_postponed_B_fail) * 4 + 1)
#define EVAL_postponed_B_fail_t8_pb ((EVAL_postponed_B_fail) * 4 + 2)
#define EVAL_postponed_B_fail_t8_p8 ((EVAL_postponed_B_fail) * 4 + 3)

/* 0x7a : 122
   CURLYX_end - state for CURLYX */
#define CURLYX_end                  (EVAL_postponed_B_fail + 1)
#define CURLYX_end_tb               ((CURLYX_end) * 2)
#define CURLYX_end_t8               ((CURLYX_end) * 2 + 1)
#define CURLYX_end_tb_pb            ((CURLYX_end) * 4)
#define CURLYX_end_tb_p8            ((CURLYX_end) * 4 + 1)
#define CURLYX_end_t8_pb            ((CURLYX_end) * 4 + 2)
#define CURLYX_end_t8_p8            ((CURLYX_end) * 4 + 3)

/* 0x7b : 123
   CURLYX_end_fail - state for CURLYX */
#define CURLYX_end_fail             (CURLYX_end + 1)
#define CURLYX_end_fail_tb          ((CURLYX_end_fail) * 2)
#define CURLYX_end_fail_t8          ((CURLYX_end_fail) * 2 + 1)
#define CURLYX_end_fail_tb_pb       ((CURLYX_end_fail) * 4)
#define CURLYX_end_fail_tb_p8       ((CURLYX_end_fail) * 4 + 1)
#define CURLYX_end_fail_t8_pb       ((CURLYX_end_fail) * 4 + 2)
#define CURLYX_end_fail_t8_p8       ((CURLYX_end_fail) * 4 + 3)

/* 0x7c : 124
   WHILEM_A_pre - state for WHILEM */
#define WHILEM_A_pre                (CURLYX_end_fail + 1)
#define WHILEM_A_pre_tb             ((WHILEM_A_pre) * 2)
#define WHILEM_A_pre_t8             ((WHILEM_A_pre) * 2 + 1)
#define WHILEM_A_pre_tb_pb          ((WHILEM_A_pre) * 4)
#define WHILEM_A_pre_tb_p8          ((WHILEM_A_pre) * 4 + 1)
#define WHILEM_A_pre_t8_pb          ((WHILEM_A_pre) * 4 + 2)
#define WHILEM_A_pre_t8_p8          ((WHILEM_A_pre) * 4 + 3)

/* 0x7d : 125
   WHILEM_A_pre_fail - state for WHILEM */
#define WHILEM_A_pre_fail           (WHILEM_A_pre + 1)
#define WHILEM_A_pre_fail_tb        ((WHILEM_A_pre_fail) * 2)
#define WHILEM_A_pre_fail_t8        ((WHILEM_A_pre_fail) * 2 + 1)
#define WHILEM_A_pre_fail_tb_pb     ((WHILEM_A_pre_fail) * 4)
#define WHILEM_A_pre_fail_tb_p8     ((WHILEM_A_pre_fail) * 4 + 1)
#define WHILEM_A_pre_fail_t8_pb     ((WHILEM_A_pre_fail) * 4 + 2)
#define WHILEM_A_pre_fail_t8_p8     ((WHILEM_A_pre_fail) * 4 + 3)

/* 0x7e : 126
   WHILEM_A_min - state for WHILEM */
#define WHILEM_A_min                (WHILEM_A_pre_fail + 1)
#define WHILEM_A_min_tb             ((WHILEM_A_min) * 2)
#define WHILEM_A_min_t8             ((WHILEM_A_min) * 2 + 1)
#define WHILEM_A_min_tb_pb          ((WHILEM_A_min) * 4)
#define WHILEM_A_min_tb_p8          ((WHILEM_A_min) * 4 + 1)
#define WHILEM_A_min_t8_pb          ((WHILEM_A_min) * 4 + 2)
#define WHILEM_A_min_t8_p8          ((WHILEM_A_min) * 4 + 3)

/* 0x7f : 127
   WHILEM_A_min_fail - state for WHILEM */
#define WHILEM_A_min_fail           (WHILEM_A_min + 1)
#define WHILEM_A_min_fail_tb        ((WHILEM_A_min_fail) * 2)
#define WHILEM_A_min_fail_t8        ((WHILEM_A_min_fail) * 2 + 1)
#define WHILEM_A_min_fail_tb_pb     ((WHILEM_A_min_fail) * 4)
#define WHILEM_A_min_fail_tb_p8     ((WHILEM_A_min_fail) * 4 + 1)
#define WHILEM_A_min_fail_t8_pb     ((WHILEM_A_min_fail) * 4 + 2)
#define WHILEM_A_min_fail_t8_p8     ((WHILEM_A_min_fail) * 4 + 3)

/* 0x80 : 128
   WHILEM_A_max - state for WHILEM */
#define WHILEM_A_max                (WHILEM_A_min_fail + 1)
#define WHILEM_A_max_tb             ((WHILEM_A_max) * 2)
#define WHILEM_A_max_t8             ((WHILEM_A_max) * 2 + 1)
#define WHILEM_A_max_tb_pb          ((WHILEM_A_max) * 4)
#define WHILEM_A_max_tb_p8          ((WHILEM_A_max) * 4 + 1)
#define WHILEM_A_max_t8_pb          ((WHILEM_A_max) * 4 + 2)
#define WHILEM_A_max_t8_p8          ((WHILEM_A_max) * 4 + 3)

/* 0x81 : 129
   WHILEM_A_max_fail - state for WHILEM */
#define WHILEM_A_max_fail           (WHILEM_A_max + 1)
#define WHILEM_A_max_fail_tb        ((WHILEM_A_max_fail) * 2)
#define WHILEM_A_max_fail_t8        ((WHILEM_A_max_fail) * 2 + 1)
#define WHILEM_A_max_fail_tb_pb     ((WHILEM_A_max_fail) * 4)
#define WHILEM_A_max_fail_tb_p8     ((WHILEM_A_max_fail) * 4 + 1)
#define WHILEM_A_max_fail_t8_pb     ((WHILEM_A_max_fail) * 4 + 2)
#define WHILEM_A_max_fail_t8_p8     ((WHILEM_A_max_fail) * 4 + 3)

/* 0x82 : 130
   WHILEM_B_min - state for WHILEM */
#define WHILEM_B_min                (WHILEM_A_max_fail + 1)
#define WHILEM_B_min_tb             ((WHILEM_B_min) * 2)
#define WHILEM_B_min_t8             ((WHILEM_B_min) * 2 + 1)
#define WHILEM_B_min_tb_pb          ((WHILEM_B_min) * 4)
#define WHILEM_B_min_tb_p8          ((WHILEM_B_min) * 4 + 1)
#define WHILEM_B_min_t8_pb          ((WHILEM_B_min) * 4 + 2)
#define WHILEM_B_min_t8_p8          ((WHILEM_B_min) * 4 + 3)

/* 0x83 : 131
   WHILEM_B_min_fail - state for WHILEM */
#define WHILEM_B_min_fail           (WHILEM_B_min + 1)
#define WHILEM_B_min_fail_tb        ((WHILEM_B_min_fail) * 2)
#define WHILEM_B_min_fail_t8        ((WHILEM_B_min_fail) * 2 + 1)
#define WHILEM_B_min_fail_tb_pb     ((WHILEM_B_min_fail) * 4)
#define WHILEM_B_min_fail_tb_p8     ((WHILEM_B_min_fail) * 4 + 1)
#define WHILEM_B_min_fail_t8_pb     ((WHILEM_B_min_fail) * 4 + 2)
#define WHILEM_B_min_fail_t8_p8     ((WHILEM_B_min_fail) * 4 + 3)

/* 0x84 : 132
   WHILEM_B_max - state for WHILEM */
#define WHILEM_B_max                (WHILEM_B_min_fail + 1)
#define WHILEM_B_max_tb             ((WHILEM_B_max) * 2)
#define WHILEM_B_max_t8             ((WHILEM_B_max) * 2 + 1)
#define WHILEM_B_max_tb_pb          ((WHILEM_B_max) * 4)
#define WHILEM_B_max_tb_p8          ((WHILEM_B_max) * 4 + 1)
#define WHILEM_B_max_t8_pb          ((WHILEM_B_max) * 4 + 2)
#define WHILEM_B_max_t8_p8          ((WHILEM_B_max) * 4 + 3)

/* 0x85 : 133
   WHILEM_B_max_fail - state for WHILEM */
#define WHILEM_B_max_fail           (WHILEM_B_max + 1)
#define WHILEM_B_max_fail_tb        ((WHILEM_B_max_fail) * 2)
#define WHILEM_B_max_fail_t8        ((WHILEM_B_max_fail) * 2 + 1)
#define WHILEM_B_max_fail_tb_pb     ((WHILEM_B_max_fail) * 4)
#define WHILEM_B_max_fail_tb_p8     ((WHILEM_B_max_fail) * 4 + 1)
#define WHILEM_B_max_fail_t8_pb     ((WHILEM_B_max_fail) * 4 + 2)
#define WHILEM_B_max_fail_t8_p8     ((WHILEM_B_max_fail) * 4 + 3)

/* 0x86 : 134
   BRANCH_next - state for BRANCH */
#define BRANCH_next                 (WHILEM_B_max_fail + 1)
#define BRANCH_next_tb              ((BRANCH_next) * 2)
#define BRANCH_next_t8              ((BRANCH_next) * 2 + 1)
#define BRANCH_next_tb_pb           ((BRANCH_next) * 4)
#define BRANCH_next_tb_p8           ((BRANCH_next) * 4 + 1)
#define BRANCH_next_t8_pb           ((BRANCH_next) * 4 + 2)
#define BRANCH_next_t8_p8           ((BRANCH_next) * 4 + 3)

/* 0x87 : 135
   BRANCH_next_fail - state for BRANCH */
#define BRANCH_next_fail            (BRANCH_next + 1)
#define BRANCH_next_fail_tb         ((BRANCH_next_fail) * 2)
#define BRANCH_next_fail_t8         ((BRANCH_next_fail) * 2 + 1)
#define BRANCH_next_fail_tb_pb      ((BRANCH_next_fail) * 4)
#define BRANCH_next_fail_tb_p8      ((BRANCH_next_fail) * 4 + 1)
#define BRANCH_next_fail_t8_pb      ((BRANCH_next_fail) * 4 + 2)
#define BRANCH_next_fail_t8_p8      ((BRANCH_next_fail) * 4 + 3)

/* 0x88 : 136
   CURLYM_A - state for CURLYM */
#define CURLYM_A                    (BRANCH_next_fail + 1)
#define CURLYM_A_tb                 ((CURLYM_A) * 2)
#define CURLYM_A_t8                 ((CURLYM_A) * 2 + 1)
#define CURLYM_A_tb_pb              ((CURLYM_A) * 4)
#define CURLYM_A_tb_p8              ((CURLYM_A) * 4 + 1)
#define CURLYM_A_t8_pb              ((CURLYM_A) * 4 + 2)
#define CURLYM_A_t8_p8              ((CURLYM_A) * 4 + 3)

/* 0x89 : 137
   CURLYM_A_fail - state for CURLYM */
#define CURLYM_A_fail               (CURLYM_A + 1)
#define CURLYM_A_fail_tb            ((CURLYM_A_fail) * 2)
#define CURLYM_A_fail_t8            ((CURLYM_A_fail) * 2 + 1)
#define CURLYM_A_fail_tb_pb         ((CURLYM_A_fail) * 4)
#define CURLYM_A_fail_tb_p8         ((CURLYM_A_fail) * 4 + 1)
#define CURLYM_A_fail_t8_pb         ((CURLYM_A_fail) * 4 + 2)
#define CURLYM_A_fail_t8_p8         ((CURLYM_A_fail) * 4 + 3)

/* 0x8a : 138
   CURLYM_B - state for CURLYM */
#define CURLYM_B                    (CURLYM_A_fail + 1)
#define CURLYM_B_tb                 ((CURLYM_B) * 2)
#define CURLYM_B_t8                 ((CURLYM_B) * 2 + 1)
#define CURLYM_B_tb_pb              ((CURLYM_B) * 4)
#define CURLYM_B_tb_p8              ((CURLYM_B) * 4 + 1)
#define CURLYM_B_t8_pb              ((CURLYM_B) * 4 + 2)
#define CURLYM_B_t8_p8              ((CURLYM_B) * 4 + 3)

/* 0x8b : 139
   CURLYM_B_fail - state for CURLYM */
#define CURLYM_B_fail               (CURLYM_B + 1)
#define CURLYM_B_fail_tb            ((CURLYM_B_fail) * 2)
#define CURLYM_B_fail_t8            ((CURLYM_B_fail) * 2 + 1)
#define CURLYM_B_fail_tb_pb         ((CURLYM_B_fail) * 4)
#define CURLYM_B_fail_tb_p8         ((CURLYM_B_fail) * 4 + 1)
#define CURLYM_B_fail_t8_pb         ((CURLYM_B_fail) * 4 + 2)
#define CURLYM_B_fail_t8_p8         ((CURLYM_B_fail) * 4 + 3)

/* 0x8c : 140
   IFMATCH_A - state for IFMATCH */
#define IFMATCH_A                   (CURLYM_B_fail + 1)
#define IFMATCH_A_tb                ((IFMATCH_A) * 2)
#define IFMATCH_A_t8                ((IFMATCH_A) * 2 + 1)
#define IFMATCH_A_tb_pb             ((IFMATCH_A) * 4)
#define IFMATCH_A_tb_p8             ((IFMATCH_A) * 4 + 1)
#define IFMATCH_A_t8_pb             ((IFMATCH_A) * 4 + 2)
#define IFMATCH_A_t8_p8             ((IFMATCH_A) * 4 + 3)

/* 0x8d : 141
   IFMATCH_A_fail - state for IFMATCH */
#define IFMATCH_A_fail              (IFMATCH_A + 1)
#define IFMATCH_A_fail_tb           ((IFMATCH_A_fail) * 2)
#define IFMATCH_A_fail_t8           ((IFMATCH_A_fail) * 2 + 1)
#define IFMATCH_A_fail_tb_pb        ((IFMATCH_A_fail) * 4)
#define IFMATCH_A_fail_tb_p8        ((IFMATCH_A_fail) * 4 + 1)
#define IFMATCH_A_fail_t8_pb        ((IFMATCH_A_fail) * 4 + 2)
#define IFMATCH_A_fail_t8_p8        ((IFMATCH_A_fail) * 4 + 3)

/* 0x8e : 142
   CURLY_B_min - state for CURLY */
#define CURLY_B_min                 (IFMATCH_A_fail + 1)
#define CURLY_B_min_tb              ((CURLY_B_min) * 2)
#define CURLY_B_min_t8              ((CURLY_B_min) * 2 + 1)
#define CURLY_B_min_tb_pb           ((CURLY_B_min) * 4)
#define CURLY_B_min_tb_p8           ((CURLY_B_min) * 4 + 1)
#define CURLY_B_min_t8_pb           ((CURLY_B_min) * 4 + 2)
#define CURLY_B_min_t8_p8           ((CURLY_B_min) * 4 + 3)

/* 0x8f : 143
   CURLY_B_min_fail - state for CURLY */
#define CURLY_B_min_fail            (CURLY_B_min + 1)
#define CURLY_B_min_fail_tb         ((CURLY_B_min_fail) * 2)
#define CURLY_B_min_fail_t8         ((CURLY_B_min_fail) * 2 + 1)
#define CURLY_B_min_fail_tb_pb      ((CURLY_B_min_fail) * 4)
#define CURLY_B_min_fail_tb_p8      ((CURLY_B_min_fail) * 4 + 1)
#define CURLY_B_min_fail_t8_pb      ((CURLY_B_min_fail) * 4 + 2)
#define CURLY_B_min_fail_t8_p8      ((CURLY_B_min_fail) * 4 + 3)

/* 0x90 : 144
   CURLY_B_max - state for CURLY */
#define CURLY_B_max                 (CURLY_B_min_fail + 1)
#define CURLY_B_max_tb              ((CURLY_B_max) * 2)
#define CURLY_B_max_t8              ((CURLY_B_max) * 2 + 1)
#define CURLY_B_max_tb_pb           ((CURLY_B_max) * 4)
#define CURLY_B_max_tb_p8           ((CURLY_B_max) * 4 + 1)
#define CURLY_B_max_t8_pb           ((CURLY_B_max) * 4 + 2)
#define CURLY_B_max_t8_p8           ((CURLY_B_max) * 4 + 3)

/* 0x91 : 145
   CURLY_B_max_fail - state for CURLY */
#define CURLY_B_max_fail            (CURLY_B_max + 1)
#define CURLY_B_max_fail_tb         ((CURLY_B_max_fail) * 2)
#define CURLY_B_max_fail_t8         ((CURLY_B_max_fail) * 2 + 1)
#define CURLY_B_max_fail_tb_pb      ((CURLY_B_max_fail) * 4)
#define CURLY_B_max_fail_tb_p8      ((CURLY_B_max_fail) * 4 + 1)
#define CURLY_B_max_fail_t8_pb      ((CURLY_B_max_fail) * 4 + 2)
#define CURLY_B_max_fail_t8_p8      ((CURLY_B_max_fail) * 4 + 3)

/* 0x92 : 146
   COMMIT_next - state for COMMIT */
#define COMMIT_next                 (CURLY_B_max_fail + 1)
#define COMMIT_next_tb              ((COMMIT_next) * 2)
#define COMMIT_next_t8              ((COMMIT_next) * 2 + 1)
#define COMMIT_next_tb_pb           ((COMMIT_next) * 4)
#define COMMIT_next_tb_p8           ((COMMIT_next) * 4 + 1)
#define COMMIT_next_t8_pb           ((COMMIT_next) * 4 + 2)
#define COMMIT_next_t8_p8           ((COMMIT_next) * 4 + 3)

/* 0x93 : 147
   COMMIT_next_fail - state for COMMIT */
#define COMMIT_next_fail            (COMMIT_next + 1)
#define COMMIT_next_fail_tb         ((COMMIT_next_fail) * 2)
#define COMMIT_next_fail_t8         ((COMMIT_next_fail) * 2 + 1)
#define COMMIT_next_fail_tb_pb      ((COMMIT_next_fail) * 4)
#define COMMIT_next_fail_tb_p8      ((COMMIT_next_fail) * 4 + 1)
#define COMMIT_next_fail_t8_pb      ((COMMIT_next_fail) * 4 + 2)
#define COMMIT_next_fail_t8_p8      ((COMMIT_next_fail) * 4 + 3)

/* 0x94 : 148
   MARKPOINT_next - state for MARKPOINT */
#define MARKPOINT_next              (COMMIT_next_fail + 1)
#define MARKPOINT_next_tb           ((MARKPOINT_next) * 2)
#define MARKPOINT_next_t8           ((MARKPOINT_next) * 2 + 1)
#define MARKPOINT_next_tb_pb        ((MARKPOINT_next) * 4)
#define MARKPOINT_next_tb_p8        ((MARKPOINT_next) * 4 + 1)
#define MARKPOINT_next_t8_pb        ((MARKPOINT_next) * 4 + 2)
#define MARKPOINT_next_t8_p8        ((MARKPOINT_next) * 4 + 3)

/* 0x95 : 149
   MARKPOINT_next_fail - state for MARKPOINT */
#define MARKPOINT_next_fail         (MARKPOINT_next + 1)
#define MARKPOINT_next_fail_tb      ((MARKPOINT_next_fail) * 2)
#define MARKPOINT_next_fail_t8      ((MARKPOINT_next_fail) * 2 + 1)
#define MARKPOINT_next_fail_tb_pb   ((MARKPOINT_next_fail) * 4)
#define MARKPOINT_next_fail_tb_p8   ((MARKPOINT_next_fail) * 4 + 1)
#define MARKPOINT_next_fail_t8_pb   ((MARKPOINT_next_fail) * 4 + 2)
#define MARKPOINT_next_fail_t8_p8   ((MARKPOINT_next_fail) * 4 + 3)

/* 0x96 : 150
   SKIP_next - state for SKIP */
#define SKIP_next                   (MARKPOINT_next_fail + 1)
#define SKIP_next_tb                ((SKIP_next) * 2)
#define SKIP_next_t8                ((SKIP_next) * 2 + 1)
#define SKIP_next_tb_pb             ((SKIP_next) * 4)
#define SKIP_next_tb_p8             ((SKIP_next) * 4 + 1)
#define SKIP_next_t8_pb             ((SKIP_next) * 4 + 2)
#define SKIP_next_t8_p8             ((SKIP_next) * 4 + 3)

/* 0x97 : 151
   SKIP_next_fail - state for SKIP */
#define SKIP_next_fail              (SKIP_next + 1)
#define SKIP_next_fail_tb           ((SKIP_next_fail) * 2)
#define SKIP_next_fail_t8           ((SKIP_next_fail) * 2 + 1)
#define SKIP_next_fail_tb_pb        ((SKIP_next_fail) * 4)
#define SKIP_next_fail_tb_p8        ((SKIP_next_fail) * 4 + 1)
#define SKIP_next_fail_t8_pb        ((SKIP_next_fail) * 4 + 2)
#define SKIP_next_fail_t8_p8        ((SKIP_next_fail) * 4 + 3)

/* 0x98 : 152
   CUTGROUP_next - state for CUTGROUP */
#define CUTGROUP_next               (SKIP_next_fail + 1)
#define CUTGROUP_next_tb            ((CUTGROUP_next) * 2)
#define CUTGROUP_next_t8            ((CUTGROUP_next) * 2 + 1)
#define CUTGROUP_next_tb_pb         ((CUTGROUP_next) * 4)
#define CUTGROUP_next_tb_p8         ((CUTGROUP_next) * 4 + 1)
#define CUTGROUP_next_t8_pb         ((CUTGROUP_next) * 4 + 2)
#define CUTGROUP_next_t8_p8         ((CUTGROUP_next) * 4 + 3)

/* 0x99 : 153
   CUTGROUP_next_fail - state for CUTGROUP */
#define CUTGROUP_next_fail          (CUTGROUP_next + 1)
#define CUTGROUP_next_fail_tb       ((CUTGROUP_next_fail) * 2)
#define CUTGROUP_next_fail_t8       ((CUTGROUP_next_fail) * 2 + 1)
#define CUTGROUP_next_fail_tb_pb    ((CUTGROUP_next_fail) * 4)
#define CUTGROUP_next_fail_tb_p8    ((CUTGROUP_next_fail) * 4 + 1)
#define CUTGROUP_next_fail_t8_pb    ((CUTGROUP_next_fail) * 4 + 2)
#define CUTGROUP_next_fail_t8_p8    ((CUTGROUP_next_fail) * 4 + 3)

/* 0x9a : 154
   KEEPS_next - state for KEEPS */
#define KEEPS_next                  (CUTGROUP_next_fail + 1)
#define KEEPS_next_tb               ((KEEPS_next) * 2)
#define KEEPS_next_t8               ((KEEPS_next) * 2 + 1)
#define KEEPS_next_tb_pb            ((KEEPS_next) * 4)
#define KEEPS_next_tb_p8            ((KEEPS_next) * 4 + 1)
#define KEEPS_next_t8_pb            ((KEEPS_next) * 4 + 2)
#define KEEPS_next_t8_p8            ((KEEPS_next) * 4 + 3)

/* 0x9b : 155
   KEEPS_next_fail - state for KEEPS */
#define KEEPS_next_fail             (KEEPS_next + 1)
#define KEEPS_next_fail_tb          ((KEEPS_next_fail) * 2)
#define KEEPS_next_fail_t8          ((KEEPS_next_fail) * 2 + 1)
#define KEEPS_next_fail_tb_pb       ((KEEPS_next_fail) * 4)
#define KEEPS_next_fail_tb_p8       ((KEEPS_next_fail) * 4 + 1)
#define KEEPS_next_fail_t8_pb       ((KEEPS_next_fail) * 4 + 2)
#define KEEPS_next_fail_t8_p8       ((KEEPS_next_fail) * 4 + 3)

/* 0x9c : 156
   REF_next - state for REF */
#define REF_next                    (KEEPS_next_fail + 1)
#define REF_next_tb                 ((REF_next) * 2)
#define REF_next_t8                 ((REF_next) * 2 + 1)
#define REF_next_tb_pb              ((REF_next) * 4)
#define REF_next_tb_p8              ((REF_next) * 4 + 1)
#define REF_next_t8_pb              ((REF_next) * 4 + 2)
#define REF_next_t8_p8              ((REF_next) * 4 + 3)

/* 0x9d : 157
   REF_next_fail - state for REF */
#define REF_next_fail               (REF_next + 1)
#define REF_next_fail_tb            ((REF_next_fail) * 2)
#define REF_next_fail_t8            ((REF_next_fail) * 2 + 1)
#define REF_next_fail_tb_pb         ((REF_next_fail) * 4)
#define REF_next_fail_tb_p8         ((REF_next_fail) * 4 + 1)
#define REF_next_fail_t8_pb         ((REF_next_fail) * 4 + 2)
#define REF_next_fail_t8_p8         ((REF_next_fail) * 4 + 3)


/* PL_regnode_name[] - Opcode/state names in string form, for debugging */

EXTCONST char * const PL_regnode_name[]  INIT( {
	"END",                   	/* 0000 */
	"SUCCEED",               	/* 0x01 */
	"LOOKBEHIND_END",        	/* 0x02 */
	"SBOL",                  	/* 0x03 */
	"MBOL",                  	/* 0x04 */
	"SEOL",                  	/* 0x05 */
	"MEOL",                  	/* 0x06 */
	"EOS",                   	/* 0x07 */
	"GPOS",                  	/* 0x08 */
	"BOUND",                 	/* 0x09 */
	"BOUNDL",                	/* 0x0a */
	"BOUNDU",                	/* 0x0b */
	"BOUNDA",                	/* 0x0c */
	"NBOUND",                	/* 0x0d */
	"NBOUNDL",               	/* 0x0e */
	"NBOUNDU",               	/* 0x0f */
	"NBOUNDA",               	/* 0x10 */
	"REG_ANY",               	/* 0x11 */
	"SANY",                  	/* 0x12 */
	"ANYOF",                 	/* 0x13 */
	"ANYOFD",                	/* 0x14 */
	"ANYOFL",                	/* 0x15 */
	"ANYOFPOSIXL",           	/* 0x16 */
	"ANYOFH",                	/* 0x17 */
	"ANYOFHb",               	/* 0x18 */
	"ANYOFHr",               	/* 0x19 */
	"ANYOFHs",               	/* 0x1a */
	"ANYOFR",                	/* 0x1b */
	"ANYOFRb",               	/* 0x1c */
	"ANYOFHbbm",             	/* 0x1d */
	"ANYOFM",                	/* 0x1e */
	"NANYOFM",               	/* 0x1f */
	"POSIXD",                	/* 0x20 */
	"POSIXL",                	/* 0x21 */
	"POSIXU",                	/* 0x22 */
	"POSIXA",                	/* 0x23 */
	"NPOSIXD",               	/* 0x24 */
	"NPOSIXL",               	/* 0x25 */
	"NPOSIXU",               	/* 0x26 */
	"NPOSIXA",               	/* 0x27 */
	"CLUMP",                 	/* 0x28 */
	"BRANCH",                	/* 0x29 */
	"EXACT",                 	/* 0x2a */
	"LEXACT",                	/* 0x2b */
	"EXACTL",                	/* 0x2c */
	"EXACTF",                	/* 0x2d */
	"EXACTFL",               	/* 0x2e */
	"EXACTFU",               	/* 0x2f */
	"EXACTFAA",              	/* 0x30 */
	"EXACTFAA_NO_TRIE",      	/* 0x31 */
	"EXACTFUP",              	/* 0x32 */
	"EXACTFLU8",             	/* 0x33 */
	"EXACT_REQ8",            	/* 0x34 */
	"LEXACT_REQ8",           	/* 0x35 */
	"EXACTFU_REQ8",          	/* 0x36 */
	"EXACTFU_S_EDGE",        	/* 0x37 */
	"LNBREAK",               	/* 0x38 */
	"TRIE",                  	/* 0x39 */
	"TRIEC",                 	/* 0x3a */
	"AHOCORASICK",           	/* 0x3b */
	"AHOCORASICKC",          	/* 0x3c */
	"LTRIE",                 	/* 0x3d */
	"LTRIEC",                	/* 0x3e */
	"NOTHING",               	/* 0x3f */
	"TAIL",                  	/* 0x40 */
	"OPTIMIZED",             	/* 0x41 */
	"STAR",                  	/* 0x42 */
	"PLUS",                  	/* 0x43 */
	"CURLY",                 	/* 0x44 */
	"CURLYN",                	/* 0x45 */
	"CURLYM",                	/* 0x46 */
	"CURLYX",                	/* 0x47 */
	"WHILEM",                	/* 0x48 */
	"OPEN",                  	/* 0x49 */
	"CLOSE",                 	/* 0x4a */
	"SROPEN",                	/* 0x4b */
	"SRCLOSE",               	/* 0x4c */
	"REF",                   	/* 0x4d */
	"REFF",                  	/* 0x4e */
	"REFFL",                 	/* 0x4f */
	"REFFU",                 	/* 0x50 */
	"REFFA",                 	/* 0x51 */
	"REFN",                  	/* 0x52 */
	"REFFN",                 	/* 0x53 */
	"REFFLN",                	/* 0x54 */
	"REFFUN",                	/* 0x55 */
	"REFFAN",                	/* 0x56 */
	"BRANCHJ",               	/* 0x57 */
	"IFMATCH",               	/* 0x58 */
	"UNLESSM",               	/* 0x59 */
	"SUSPEND",               	/* 0x5a */
	"IFTHEN",                	/* 0x5b */
	"RENUM",                 	/* 0x5c */
	"LONGJMP",               	/* 0x5d */
	"MINMOD",                	/* 0x5e */
	"LOGICAL",               	/* 0x5f */
	"EVAL",                  	/* 0x60 */
	"GOSUB",                 	/* 0x61 */
	"GROUPP",                	/* 0x62 */
	"GROUPPN",               	/* 0x63 */
	"INSUBP",                	/* 0x64 */
	"DEFINEP",               	/* 0x65 */
	"ENDLIKE",               	/* 0x66 */
	"OPFAIL",                	/* 0x67 */
	"ACCEPT",                	/* 0x68 */
	"VERB",                  	/* 0x69 */
	"PRUNE",                 	/* 0x6a */
	"MARKPOINT",             	/* 0x6b */
	"SKIP",                  	/* 0x6c */
	"COMMIT",                	/* 0x6d */
	"CUTGROUP",              	/* 0x6e */
	"KEEPS",                 	/* 0x6f */
	"PSEUDO",                	/* 0x70 */
	"REGEX_SET",             	/* 0x71 */
	/* ------------ States ------------- */
	"TRIE_next",             	/* REGNODE_MAX +0x01 */
	"TRIE_next_fail",        	/* REGNODE_MAX +0x02 */
	"EVAL_B",                	/* REGNODE_MAX +0x03 */
	"EVAL_B_fail",           	/* REGNODE_MAX +0x04 */
	"EVAL_postponed_A",      	/* REGNODE_MAX +0x05 */
	"EVAL_postponed_A_fail", 	/* REGNODE_MAX +0x06 */
	"EVAL_postponed_B",      	/* REGNODE_MAX +0x07 */
	"EVAL_postponed_B_fail", 	/* REGNODE_MAX +0x08 */
	"CURLYX_end",            	/* REGNODE_MAX +0x09 */
	"CURLYX_end_fail",       	/* REGNODE_MAX +0x0a */
	"WHILEM_A_pre",          	/* REGNODE_MAX +0x0b */
	"WHILEM_A_pre_fail",     	/* REGNODE_MAX +0x0c */
	"WHILEM_A_min",          	/* REGNODE_MAX +0x0d */
	"WHILEM_A_min_fail",     	/* REGNODE_MAX +0x0e */
	"WHILEM_A_max",          	/* REGNODE_MAX +0x0f */
	"WHILEM_A_max_fail",     	/* REGNODE_MAX +0x10 */
	"WHILEM_B_min",          	/* REGNODE_MAX +0x11 */
	"WHILEM_B_min_fail",     	/* REGNODE_MAX +0x12 */
	"WHILEM_B_max",          	/* REGNODE_MAX +0x13 */
	"WHILEM_B_max_fail",     	/* REGNODE_MAX +0x14 */
	"BRANCH_next",           	/* REGNODE_MAX +0x15 */
	"BRANCH_next_fail",      	/* REGNODE_MAX +0x16 */
	"CURLYM_A",              	/* REGNODE_MAX +0x17 */
	"CURLYM_A_fail",         	/* REGNODE_MAX +0x18 */
	"CURLYM_B",              	/* REGNODE_MAX +0x19 */
	"CURLYM_B_fail",         	/* REGNODE_MAX +0x1a */
	"IFMATCH_A",             	/* REGNODE_MAX +0x1b */
	"IFMATCH_A_fail",        	/* REGNODE_MAX +0x1c */
	"CURLY_B_min",           	/* REGNODE_MAX +0x1d */
	"CURLY_B_min_fail",      	/* REGNODE_MAX +0x1e */
	"CURLY_B_max",           	/* REGNODE_MAX +0x1f */
	"CURLY_B_max_fail",      	/* REGNODE_MAX +0x20 */
	"COMMIT_next",           	/* REGNODE_MAX +0x21 */
	"COMMIT_next_fail",      	/* REGNODE_MAX +0x22 */
	"MARKPOINT_next",        	/* REGNODE_MAX +0x23 */
	"MARKPOINT_next_fail",   	/* REGNODE_MAX +0x24 */
	"SKIP_next",             	/* REGNODE_MAX +0x25 */
	"SKIP_next_fail",        	/* REGNODE_MAX +0x26 */
	"CUTGROUP_next",         	/* REGNODE_MAX +0x27 */
	"CUTGROUP_next_fail",    	/* REGNODE_MAX +0x28 */
	"KEEPS_next",            	/* REGNODE_MAX +0x29 */
	"KEEPS_next_fail",       	/* REGNODE_MAX +0x2a */
	"REF_next",              	/* REGNODE_MAX +0x2b */
	"REF_next_fail",         	/* REGNODE_MAX +0x2c */
});


/* PL_regnode_info[] - Opcode/state names in string form, for debugging */

EXTCONST struct regnode_meta PL_regnode_info[]  INIT( {
    {
        /* #0 op END */
        .type = END,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #1 op SUCCEED */
        .type = END,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #2 op LOOKBEHIND_END */
        .type = END,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #3 op SBOL */
        .type = BOL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #4 op MBOL */
        .type = BOL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #5 op SEOL */
        .type = EOL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #6 op MEOL */
        .type = EOL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #7 op EOS */
        .type = EOL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #8 op GPOS */
        .type = GPOS,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #9 op BOUND */
        .type = BOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #10 op BOUNDL */
        .type = BOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #11 op BOUNDU */
        .type = BOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #12 op BOUNDA */
        .type = BOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #13 op NBOUND */
        .type = NBOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #14 op NBOUNDL */
        .type = NBOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #15 op NBOUNDU */
        .type = NBOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #16 op NBOUNDA */
        .type = NBOUND,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #17 op REG_ANY */
        .type = REG_ANY,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #18 op SANY */
        .type = REG_ANY,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #19 op ANYOF */
        .type = ANYOF,
        .arg_len = EXTRA_SIZE(tregnode_ANYOF),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #20 op ANYOFD */
        .type = ANYOF,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFD),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #21 op ANYOFL */
        .type = ANYOF,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFL),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #22 op ANYOFPOSIXL */
        .type = ANYOF,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFPOSIXL),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #23 op ANYOFH */
        .type = ANYOFH,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFH),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #24 op ANYOFHb */
        .type = ANYOFH,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFHb),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #25 op ANYOFHr */
        .type = ANYOFH,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFHr),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #26 op ANYOFHs */
        .type = ANYOFH,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFHs),
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #27 op ANYOFR */
        .type = ANYOFR,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFR),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #28 op ANYOFRb */
        .type = ANYOFR,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFRb),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #29 op ANYOFHbbm */
        .type = ANYOFHbbm,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFHbbm),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #30 op ANYOFM */
        .type = ANYOFM,
        .arg_len = EXTRA_SIZE(tregnode_ANYOFM),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #31 op NANYOFM */
        .type = ANYOFM,
        .arg_len = EXTRA_SIZE(tregnode_NANYOFM),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #32 op POSIXD */
        .type = POSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #33 op POSIXL */
        .type = POSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #34 op POSIXU */
        .type = POSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #35 op POSIXA */
        .type = POSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #36 op NPOSIXD */
        .type = NPOSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #37 op NPOSIXL */
        .type = NPOSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #38 op NPOSIXU */
        .type = NPOSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #39 op NPOSIXA */
        .type = NPOSIXD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #40 op CLUMP */
        .type = CLUMP,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #41 op BRANCH */
        .type = BRANCH,
        .arg_len = EXTRA_SIZE(tregnode_BRANCH),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #42 op EXACT */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #43 op LEXACT */
        .type = EXACT,
        .arg_len = EXTRA_SIZE(tregnode_LEXACT),
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #44 op EXACTL */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #45 op EXACTF */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #46 op EXACTFL */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #47 op EXACTFU */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #48 op EXACTFAA */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #49 op EXACTFAA_NO_TRIE */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #50 op EXACTFUP */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #51 op EXACTFLU8 */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #52 op EXACT_REQ8 */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #53 op LEXACT_REQ8 */
        .type = EXACT,
        .arg_len = EXTRA_SIZE(tregnode_LEXACT_REQ8),
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #54 op EXACTFU_REQ8 */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #55 op EXACTFU_S_EDGE */
        .type = EXACT,
        .arg_len = 0,
        .arg_len_varies = 1,
        .off_by_arg = 0
    },
    {
        /* #56 op LNBREAK */
        .type = LNBREAK,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #57 op TRIE */
        .type = TRIE,
        .arg_len = EXTRA_SIZE(tregnode_TRIE),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #58 op TRIEC */
        .type = TRIE,
        .arg_len = EXTRA_SIZE(tregnode_TRIEC),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #59 op AHOCORASICK */
        .type = TRIE,
        .arg_len = EXTRA_SIZE(tregnode_AHOCORASICK),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #60 op AHOCORASICKC */
        .type = TRIE,
        .arg_len = EXTRA_SIZE(tregnode_AHOCORASICKC),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #61 op LTRIE */
        .type = TRIE,
        .arg_len = EXTRA_SIZE(tregnode_LTRIE),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #62 op LTRIEC */
        .type = TRIE,
        .arg_len = EXTRA_SIZE(tregnode_LTRIEC),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #63 op NOTHING */
        .type = NOTHING,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #64 op TAIL */
        .type = NOTHING,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #65 op OPTIMIZED */
        .type = NOTHING,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #66 op STAR */
        .type = STAR,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #67 op PLUS */
        .type = PLUS,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #68 op CURLY */
        .type = CURLY,
        .arg_len = EXTRA_SIZE(tregnode_CURLY),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #69 op CURLYN */
        .type = CURLY,
        .arg_len = EXTRA_SIZE(tregnode_CURLYN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #70 op CURLYM */
        .type = CURLY,
        .arg_len = EXTRA_SIZE(tregnode_CURLYM),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #71 op CURLYX */
        .type = CURLY,
        .arg_len = EXTRA_SIZE(tregnode_CURLYX),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #72 op WHILEM */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #73 op OPEN */
        .type = OPEN,
        .arg_len = EXTRA_SIZE(tregnode_OPEN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #74 op CLOSE */
        .type = CLOSE,
        .arg_len = EXTRA_SIZE(tregnode_CLOSE),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #75 op SROPEN */
        .type = SROPEN,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #76 op SRCLOSE */
        .type = SRCLOSE,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #77 op REF */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REF),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #78 op REFF */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFF),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #79 op REFFL */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFL),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #80 op REFFU */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFU),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #81 op REFFA */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFA),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #82 op REFN */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #83 op REFFN */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #84 op REFFLN */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFLN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #85 op REFFUN */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFUN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #86 op REFFAN */
        .type = REF,
        .arg_len = EXTRA_SIZE(tregnode_REFFAN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #87 op BRANCHJ */
        .type = BRANCHJ,
        .arg_len = EXTRA_SIZE(tregnode_BRANCHJ),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #88 op IFMATCH */
        .type = BRANCHJ,
        .arg_len = EXTRA_SIZE(tregnode_IFMATCH),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #89 op UNLESSM */
        .type = BRANCHJ,
        .arg_len = EXTRA_SIZE(tregnode_UNLESSM),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #90 op SUSPEND */
        .type = BRANCHJ,
        .arg_len = EXTRA_SIZE(tregnode_SUSPEND),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #91 op IFTHEN */
        .type = BRANCHJ,
        .arg_len = EXTRA_SIZE(tregnode_IFTHEN),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #92 op RENUM */
        .type = BRANCHJ,
        .arg_len = EXTRA_SIZE(tregnode_RENUM),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #93 op LONGJMP */
        .type = LONGJMP,
        .arg_len = EXTRA_SIZE(tregnode_LONGJMP),
        .arg_len_varies = 0,
        .off_by_arg = 1
    },
    {
        /* #94 op MINMOD */
        .type = MINMOD,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #95 op LOGICAL */
        .type = LOGICAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #96 op EVAL */
        .type = EVAL,
        .arg_len = EXTRA_SIZE(tregnode_EVAL),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #97 op GOSUB */
        .type = GOSUB,
        .arg_len = EXTRA_SIZE(tregnode_GOSUB),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #98 op GROUPP */
        .type = GROUPP,
        .arg_len = EXTRA_SIZE(tregnode_GROUPP),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #99 op GROUPPN */
        .type = GROUPPN,
        .arg_len = EXTRA_SIZE(tregnode_GROUPPN),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #100 op INSUBP */
        .type = INSUBP,
        .arg_len = EXTRA_SIZE(tregnode_INSUBP),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #101 op DEFINEP */
        .type = DEFINEP,
        .arg_len = EXTRA_SIZE(tregnode_DEFINEP),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #102 op ENDLIKE */
        .type = ENDLIKE,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #103 op OPFAIL */
        .type = ENDLIKE,
        .arg_len = EXTRA_SIZE(tregnode_OPFAIL),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #104 op ACCEPT */
        .type = ENDLIKE,
        .arg_len = EXTRA_SIZE(tregnode_ACCEPT),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #105 op VERB */
        .type = VERB,
        .arg_len = EXTRA_SIZE(tregnode_VERB),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #106 op PRUNE */
        .type = VERB,
        .arg_len = EXTRA_SIZE(tregnode_PRUNE),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #107 op MARKPOINT */
        .type = VERB,
        .arg_len = EXTRA_SIZE(tregnode_MARKPOINT),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #108 op SKIP */
        .type = VERB,
        .arg_len = EXTRA_SIZE(tregnode_SKIP),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #109 op COMMIT */
        .type = VERB,
        .arg_len = EXTRA_SIZE(tregnode_COMMIT),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #110 op CUTGROUP */
        .type = VERB,
        .arg_len = EXTRA_SIZE(tregnode_CUTGROUP),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #111 op KEEPS */
        .type = KEEPS,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #112 op PSEUDO */
        .type = PSEUDO,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #113 op REGEX_SET */
        .type = REGEX_SET,
        .arg_len = EXTRA_SIZE(tregnode_REGEX_SET),
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #114 state TRIE_next */
        .type = TRIE,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #115 state TRIE_next_fail */
        .type = TRIE,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #116 state EVAL_B */
        .type = EVAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #117 state EVAL_B_fail */
        .type = EVAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #118 state EVAL_postponed_A */
        .type = EVAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #119 state EVAL_postponed_A_fail */
        .type = EVAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #120 state EVAL_postponed_B */
        .type = EVAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #121 state EVAL_postponed_B_fail */
        .type = EVAL,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #122 state CURLYX_end */
        .type = CURLYX,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #123 state CURLYX_end_fail */
        .type = CURLYX,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #124 state WHILEM_A_pre */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #125 state WHILEM_A_pre_fail */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #126 state WHILEM_A_min */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #127 state WHILEM_A_min_fail */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #128 state WHILEM_A_max */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #129 state WHILEM_A_max_fail */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #130 state WHILEM_B_min */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #131 state WHILEM_B_min_fail */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #132 state WHILEM_B_max */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #133 state WHILEM_B_max_fail */
        .type = WHILEM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #134 state BRANCH_next */
        .type = BRANCH,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #135 state BRANCH_next_fail */
        .type = BRANCH,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #136 state CURLYM_A */
        .type = CURLYM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #137 state CURLYM_A_fail */
        .type = CURLYM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #138 state CURLYM_B */
        .type = CURLYM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #139 state CURLYM_B_fail */
        .type = CURLYM,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #140 state IFMATCH_A */
        .type = IFMATCH,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #141 state IFMATCH_A_fail */
        .type = IFMATCH,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #142 state CURLY_B_min */
        .type = CURLY,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #143 state CURLY_B_min_fail */
        .type = CURLY,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #144 state CURLY_B_max */
        .type = CURLY,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #145 state CURLY_B_max_fail */
        .type = CURLY,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #146 state COMMIT_next */
        .type = COMMIT,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #147 state COMMIT_next_fail */
        .type = COMMIT,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #148 state MARKPOINT_next */
        .type = MARKPOINT,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #149 state MARKPOINT_next_fail */
        .type = MARKPOINT,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #150 state SKIP_next */
        .type = SKIP,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #151 state SKIP_next_fail */
        .type = SKIP,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #152 state CUTGROUP_next */
        .type = CUTGROUP,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #153 state CUTGROUP_next_fail */
        .type = CUTGROUP,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #154 state KEEPS_next */
        .type = KEEPS,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #155 state KEEPS_next_fail */
        .type = KEEPS,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #156 state REF_next */
        .type = REF,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    },
    {
        /* #157 state REF_next_fail */
        .type = REF,
        .arg_len = 0,
        .arg_len_varies = 0,
        .off_by_arg = 0
    }
});

/* PL_reg_extflags_name[] - Opcode/state names in string form, for debugging */

EXTCONST char * const PL_reg_extflags_name[] INIT( {
	/* Bits in extflags defined: 11111111111111110000111111111111 */
	"MULTILINE",        /* 0x00000001 */
	"SINGLELINE",       /* 0x00000002 */
	"FOLD",             /* 0x00000004 */
	"EXTENDED",         /* 0x00000008 */
	"EXTENDED_MORE",    /* 0x00000010 */
	"NOCAPTURE",        /* 0x00000020 */
	"KEEPCOPY",         /* 0x00000040 */
	"CHARSET0",         /* 0x00000080 : "CHARSET" - 0x00000380 */
	"CHARSET1",         /* 0x00000100 : "CHARSET" - 0x00000380 */
	"CHARSET2",         /* 0x00000200 : "CHARSET" - 0x00000380 */
	"STRICT",           /* 0x00000400 */
	"SPLIT",            /* 0x00000800 */
	"UNUSED_BIT_12",    /* 0x00001000 */
	"UNUSED_BIT_13",    /* 0x00002000 */
	"UNUSED_BIT_14",    /* 0x00004000 */
	"UNUSED_BIT_15",    /* 0x00008000 */
	"NO_INPLACE_SUBST", /* 0x00010000 */
	"EVAL_SEEN",        /* 0x00020000 */
	"UNBOUNDED_QUANTIFIER_SEEN",/* 0x00040000 */
	"CHECK_ALL",        /* 0x00080000 */
	"MATCH_UTF8",       /* 0x00100000 */
	"USE_INTUIT_NOML",  /* 0x00200000 */
	"USE_INTUIT_ML",    /* 0x00400000 */
	"INTUIT_TAIL",      /* 0x00800000 */
	"IS_ANCHORED",      /* 0x01000000 */
	"COPY_DONE",        /* 0x02000000 */
	"TAINTED_SEEN",     /* 0x04000000 */
	"TAINTED",          /* 0x08000000 */
	"START_ONLY",       /* 0x10000000 */
	"SKIPWHITE",        /* 0x20000000 */
	"WHITE",            /* 0x40000000 */
	"NULL",             /* 0x80000000 */
});

#ifdef DEBUGGING
#  define REG_EXTFLAGS_NAME_SIZE 32
#endif

/* PL_reg_intflags_name[] - Opcode/state names in string form, for debugging */

EXTCONST char * const PL_reg_intflags_name[]  INIT( {
	"SKIP",                       /* (1<< 0) - 0x00000001 - PREGf_SKIP */
	"IMPLICIT",                   /* (1<< 1) - 0x00000002 - PREGf_IMPLICIT -  Converted .* to ^.*  */
	"NAUGHTY",                    /* (1<< 2) - 0x00000004 - PREGf_NAUGHTY -  how exponential is this pattern?  */
	"VERBARG_SEEN",               /* (1<< 3) - 0x00000008 - PREGf_VERBARG_SEEN */
	"CUTGROUP_SEEN",              /* (1<< 4) - 0x00000010 - PREGf_CUTGROUP_SEEN */
	"USE_RE_EVAL",                /* (1<< 5) - 0x00000020 - PREGf_USE_RE_EVAL -  compiled with "use re 'eval'"  */
	"NOSCAN",                     /* (1<< 6) - 0x00000040 - PREGf_NOSCAN */
	"",                           /* (1<< 7) - 0x00000080 - *UNUSED* */
	"GPOS_SEEN",                  /* (1<< 8) - 0x00000100 - PREGf_GPOS_SEEN */
	"GPOS_FLOAT",                 /* (1<< 9) - 0x00000200 - PREGf_GPOS_FLOAT */
	"ANCH_MBOL",                  /* (1<<10) - 0x00000400 - PREGf_ANCH_MBOL */
	"ANCH_SBOL",                  /* (1<<11) - 0x00000800 - PREGf_ANCH_SBOL */
	"ANCH_GPOS",                  /* (1<<12) - 0x00001000 - PREGf_ANCH_GPOS */
	"RECURSE_SEEN",               /* (1<<13) - 0x00002000 - PREGf_RECURSE_SEEN */
	"PESSIMIZE_SEEN",             /* (1<<14) - 0x00004000 - PREGf_PESSIMIZE_SEEN */
});

#ifdef DEBUGGING
#  define REG_INTFLAGS_NAME_SIZE 15
#endif

/* The following have no fixed length. U8 so we can do strchr() on it. */
#define REGNODE_VARIES(node) (PL_varies_bitmask[(node) >> 3] & (1 << ((node) & 7)))

EXTCONST U8 PL_varies[] __attribute__deprecated__
INIT({ CLUMP, BRANCH, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, WHILEM, REF,
    REFF, REFFL, REFFU, REFFA, REFN, REFFN, REFFLN, REFFUN, REFFAN,
    BRANCHJ, SUSPEND, IFTHEN,
    0 });

/* varies: 000000000000000000000000000000000000000000000011000000000000000011111100111000011111111100001100000000000000000000000000 */
EXTCONST U8 PL_varies_bitmask[] INIT({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0xFC, 0xE1, 0xFF, 0x0C, 0x00, 0x00, 0x00 });

/* The following always have a length of 1. U8 we can do strchr() on it. */
/* (Note that length 1 means "one character" under UTF8, not "one octet".) */
#define REGNODE_SIMPLE(node) (PL_simple_bitmask[(node) >> 3] & (1 << ((node) & 7)))

EXTCONST U8 PL_simple[] __attribute__deprecated__
INIT({ REG_ANY, SANY, ANYOF, ANYOFD, ANYOFL, ANYOFPOSIXL, ANYOFH, ANYOFHb,
    ANYOFHr, ANYOFHs, ANYOFR, ANYOFRb, ANYOFHbbm, ANYOFM, NANYOFM, POSIXD,
    POSIXL, POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA, REGEX_SET,
    0 });

/* simple: 000000000000000011111110111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000010 */
EXTCONST U8 PL_simple_bitmask[] INIT({ 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 });

/* Is 'op', known to be of type EXACT, folding? */
#define isEXACTFish(op) (assert(REGNODE_TYPE(op) == EXACT), (PL_EXACTFish_bitmask & (1U << (op - EXACT))))

/* Do only UTF-8 target strings match 'op', known to be of type EXACT? */
#define isEXACT_REQ8(op) (assert(REGNODE_TYPE(op) == EXACT), (PL_EXACT_REQ8_bitmask & (1U << (op - EXACT))))

EXTCONST U32 PL_EXACTFish_bitmask INIT(0x33F8);
EXTCONST U32 PL_EXACT_REQ8_bitmask INIT(0x1E00);

#endif /* defined(PERL_CORE) || defined(PERL_EXT_RE_BUILD) */

/* ex: set ro ft=c: */
