insert_op2 (set_number_at, laststart, 5, lower_bound, b); b += 5;
insert_op2 (set_number_at, laststart, 1 + 2 * OFFSET_ADDRESS_SIZE, lower_bound, b); b += 1 + 2 * OFFSET_ADDRESS_SIZE;
            handle_interval:              {                /* If got here, then the syntax allows intervals.  */                /* At least (most) this many matches must be made.  */                int lower_bound = -1, upper_bound = -1;                beg_interval = p - 1;                if (p == pend)                  {                    if (!(syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))                      goto unfetch_interval;                    else                      FREE_STACK_RETURN (REG_EBRACE);                  }                GET_UNSIGNED_NUMBER (lower_bound);                if (c == ',')                  {                    GET_UNSIGNED_NUMBER (upper_bound);		    if ((!(syntax & RE_NO_BK_BRACES) && c != '\\')			|| ((syntax & RE_NO_BK_BRACES) && c != '}'))		      FREE_STACK_RETURN (REG_BADBR);		    if (upper_bound < 0)		      upper_bound = RE_DUP_MAX;                  }                else                  /* Interval such as `{1}' => match exactly once. */                  upper_bound = lower_bound;                if (lower_bound < 0 || upper_bound > RE_DUP_MAX                    || lower_bound > upper_bound)                  {                    if (!(syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))                      goto unfetch_interval;                    else                      FREE_STACK_RETURN (REG_BADBR);                  }                if (!(syntax & RE_NO_BK_BRACES))                  {                    if (c != '\\') FREE_STACK_RETURN (REG_EBRACE);                    PATFETCH (c);                  }                if (c != '}')                  {                    if (!(syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))                      goto unfetch_interval;                    else                      FREE_STACK_RETURN (REG_BADBR);                  }                /* We just parsed a valid interval.  */                /* If it's invalid to have no preceding re.  */                if (!laststart)                  {                    if (syntax & RE_CONTEXT_INVALID_OPS)                      FREE_STACK_RETURN (REG_BADRPT);                    else if (syntax & RE_CONTEXT_INDEP_OPS)                      laststart = b;                    else                      goto unfetch_interval;                  }                /* If the upper bound is zero, don't want to succeed at                   all; jump from `laststart' to `b + 3', which will be                   the end of the buffer after we insert the jump.  */                 if (upper_bound == 0)                   {                     GET_BUFFER_SPACE (3);                     INSERT_JUMP (jump, laststart, b + 3);                     b += 3;                   }                 /* Otherwise, we have a nontrivial interval.  When                    we're all done, the pattern will look like:                      set_number_at <jump count> <upper bound>                      set_number_at <succeed_n count> <lower bound>                      succeed_n <after jump addr> <succeed_n count>                      <body of loop>                      jump_n <succeed_n addr> <jump count>                    (The upper bound and `jump_n' are omitted if                    `upper_bound' is 1, though.)  */                 else                   { /* If the upper bound is > 1, we need to insert                        more at the end of the loop.  */                     unsigned nbytes = 10 + (upper_bound > 1) * 10;                     GET_BUFFER_SPACE (nbytes);                     /* Initialize lower bound of the `succeed_n', even                        though it will be set during matching by its                        attendant `set_number_at' (inserted next),                        because `re_compile_fastmap' needs to know.                        Jump to the `jump_n' we might insert below.  */                     INSERT_JUMP2 (succeed_n, laststart,                                   b + 5 + (upper_bound > 1) * 5,                                   lower_bound);                     b += 5;                     /* Code to initialize the lower bound.  Insert                        before the `succeed_n'.  The `5' is the last two                        bytes of this `set_number_at', plus 3 bytes of                        the following `succeed_n'.  */                     insert_op2 (set_number_at, laststart, 5, lower_bound, b);                     b += 5;                     if (upper_bound > 1)                       { /* More than one repetition is allowed, so                            append a backward jump to the `succeed_n'                            that starts this interval.                            When we've reached this during matching,                            we'll have matched the interval once, so                            jump back only `upper_bound - 1' times.  */                         STORE_JUMP2 (jump_n, b, laststart + 5,                                      upper_bound - 1);                         b += 5;                         /* The location we want to set is the second                            parameter of the `jump_n'; that is `b-2' as                            an absolute address.  `laststart' will be                            the `set_number_at' we're about to insert;                            `laststart+3' the number to set, the source                            for the relative address.  But we are                            inserting into the middle of the pattern --                            so everything is getting moved up by 5.                            Conclusion: (b - 2) - (laststart + 3) + 5,                            i.e., b - laststart.                            We insert this at the beginning of the loop                            so that if we fail during matching, we'll                            reinitialize the bounds.  */                         insert_op2 (set_number_at, laststart, b - laststart,                                     upper_bound - 1, b);                         b += 5;                       }                   }                pending_exact = 0;                beg_interval = NULL;              }