srell.hpp

/*****************************************************************************
**
**  SRELL (std::regex-like library) version 2026.06
**
**  Copyright (c) 2012-2026, Nozomu Katoo. All rights reserved.
**
**  Redistribution and use in source and binary forms, with or without
**  modification, are permitted provided that the following conditions are
**  met:
**
**  1. Redistributions of source code must retain the above copyright notice,
**     this list of conditions and the following disclaimer.
**
**  2. Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in the
**     documentation and/or other materials provided with the distribution.
**
**  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
**  IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
**  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
**  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
**  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
**  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
**  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
**  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
**  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
**  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
**  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
******************************************************************************
*/

#ifndef SRELL_HPP_
#define SRELL_HPP_ 202606

#include <climits>
#include <cwchar>
#include <stdexcept>
#include <limits>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#include <new>
#include <utility>
#include <vector>
#include <iterator>
#include <memory>
#include <algorithm>

#if !defined(SIZE_MAX)
//  MSVC has SIZE_MAX also in limits.h.
#include <stdint.h>
//  Skips for MSVC 2005 and 2008 which do not have stdint.h.
#endif

#if !defined(UINT_MAX) || (UINT_MAX < 0xFFFFFFFFL)
#error UINT_MAX >= 0xFFFFFFFF required.
#endif

#if !defined(SIZE_MAX) || (SIZE_MAX < 0xFFFFFFFFL)
#error SIZE_MAX >= 0xFFFFFFFF required.
#endif

#if !defined(SRELL_NO_UNISTACK) && (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSC_VER) && (_MSC_VER >= 1900))
#include <type_traits>
#define SRELL_HAS_TYPE_TRAITS
#endif

#if !defined(SRELL_NO_SIMD)
#if (defined(_M_X64) && !defined(_M_ARM64EC)) || defined(__x86_64__) || defined(_M_IX86) || defined(__i386__)
#if defined(__SSE4_2__)
	#define SRELL_HAS_SSE42 1
#elif defined(__clang__)
	#if ((__clang_major__ + 0) >= 4) || (((__clang_major__ + 0) == 3) && ((__clang_minor__ + 0) >= 8))
	#define SRELL_HAS_SSE42 1
	#endif
#elif defined(__GNUC__)
	#if ((__GNUC__ >= 5) || ((__GNUC__ == 4) && ((__GNUC_MINOR__ + 0) >= 9)))
	#define SRELL_HAS_SSE42 1
	#endif
#elif defined(_MSC_VER) && (_MSC_VER >= 1500)
	#include <intrin.h>
	#define SRELL_HAS_SSE42 2
#endif	//  sse 4.2.
#endif	//  x86/x64.
#endif

#define SRELL_AT_SSE42
#if defined(SRELL_HAS_SSE42) && (SRELL_HAS_SSE42 == 1)
	#include <x86intrin.h>
	#if !defined(__SSE4_2__)
	#undef SRELL_AT_SSE42
	#define SRELL_AT_SSE42 __attribute__((target("sse4.2")))
	#endif
#endif

//  The following SRELL_NO_* macros would be useful for reducing the
//  size of an executable file by turning off some feature(s).

#ifdef SRELL_NO_UNICODE_DATA

//  Prevents Unicode case folding data used for icase (case-insensitive)
//  matching from being output into the executable file. In this case,
//  only the ASCII characters are case-folded when icase matching is
//  performed (i.e., [A-Z] -> [a-z] only).
#define SRELL_NO_UNICODE_ICASE

//  Prevents Unicode property data from being output into the executable
//  file. In this case, \p{...} and \P{...} become unavailable.
#define SRELL_NO_UNICODE_PROPERTY
#endif

//  This macro might be removed in the future.
#ifdef SRELL_V1_COMPATIBLE
#define SRELL_NO_UNICODE_PROPERTY
#define SRELL_NO_NAMEDCAPTURE
#define SRELL_NO_SINGLELINE
//#define SRELL_FIXEDWIDTHLOOKBEHIND
//  Since version 4.019, SRELL highly depends on the variable-length
//  lookbehind feature. Uncommenting this line is not recommended.
#endif

namespace srell
{

#if defined(_MSC_VER)
#define SRELL_NO_VCWARNING(n) \
	__pragma(warning(push)) \
	__pragma(warning(disable:n))
#define SRELL_NO_VCWARNING_END __pragma(warning(pop))
#else
#define SRELL_NO_VCWARNING(n)
#define SRELL_NO_VCWARNING_END
#endif

#if defined(__cpp_rvalue_references) && (!defined(_MSC_VER) || (_MSC_VER >= 1900))
#define SRELL_NOEXCEPT noexcept
#else
#define SRELL_NOEXCEPT
#endif

#if defined(__cpp_constexpr)
#define SRELL_STACON static constexpr
#else
#define SRELL_STACON static const
#endif

#if defined(__cpp_if_constexpr)
#define SRELL_IFCE constexpr
#else
#define SRELL_IFCE
#endif

//  ["rei_type.h" ...

	namespace re_detail
	{

#if defined(__cpp_unicode_characters)
		typedef char32_t ui_l32;	//  uint_least32.
#else
		typedef unsigned int ui_l32;
#endif

		typedef std::size_t cntr_type;

	}	//  namespace re_detail

//  ... "rei_type.h"]
//  ["regex_constants.h" ...

	namespace regex_constants
	{
		enum syntax_option_type
		{
			icase = 1 << 1,
			nosubs = 1 << 2,
			optimize = 1 << 3,
			collate = 0,
			ECMAScript = 1 << 0,
			multiline = 1 << 4,
			basic = 0,
			extended = 0,
			awk = 0,
			grep = 0,
			egrep = 0,

			//  SRELL's extensions.
			sticky = 1 << 5,	//  == match_continuous below.
			dotall = 1 << 6,	//  singleline.
			unicodesets = 1 << 7,
			vmode = unicodesets,
			quiet = 1 << 8,

			//  For internal use.
			back_ = 1 << 9,
			pflagsmask_ = (1 << 9) - 1
		};

		inline syntax_option_type operator&(const syntax_option_type left, const syntax_option_type right)
		{
			return static_cast<syntax_option_type>(static_cast<int>(left) & static_cast<int>(right));
		}
		inline syntax_option_type operator|(const syntax_option_type left, const syntax_option_type right)
		{
			return static_cast<syntax_option_type>(static_cast<int>(left) | static_cast<int>(right));
		}
		inline syntax_option_type operator^(const syntax_option_type left, const syntax_option_type right)
		{
			return static_cast<syntax_option_type>(static_cast<int>(left) ^ static_cast<int>(right));
		}
		inline syntax_option_type operator~(const syntax_option_type b)
		{
			return static_cast<syntax_option_type>(~static_cast<int>(b));
		}
		inline syntax_option_type &operator&=(syntax_option_type &left, const syntax_option_type right)
		{
			left = left & right;
			return left;
		}
		inline syntax_option_type &operator|=(syntax_option_type &left, const syntax_option_type right)
		{
			left = left | right;
			return left;
		}
		inline syntax_option_type &operator^=(syntax_option_type &left, const syntax_option_type right)
		{
			left = left ^ right;
			return left;
		}
	}
	//  namespace regex_constants

	namespace regex_constants
	{
		enum match_flag_type
		{
			match_default = 0,
			match_not_bol = 1 << 0,
			match_not_eol = 1 << 1,
			match_not_bow = 1 << 2,
			match_not_eow = 1 << 3,
			match_any = 0,
			match_not_null = 1 << 4,
			match_continuous = 1 << 5,	//  == sticky above.
			match_prev_avail = 1 << 6,

			format_default = 0,
			format_sed = 0,
			format_no_copy = 1 << 7,
			format_first_only = 1 << 8,

			//  For internal use.
			match_match_ = 1 << 9
		};

		inline match_flag_type operator&(const match_flag_type left, const match_flag_type right)
		{
			return static_cast<match_flag_type>(static_cast<int>(left) & static_cast<int>(right));
		}
		inline match_flag_type operator|(const match_flag_type left, const match_flag_type right)
		{
			return static_cast<match_flag_type>(static_cast<int>(left) | static_cast<int>(right));
		}
		inline match_flag_type operator^(const match_flag_type left, const match_flag_type right)
		{
			return static_cast<match_flag_type>(static_cast<int>(left) ^ static_cast<int>(right));
		}
		inline match_flag_type operator~(const match_flag_type b)
		{
			return static_cast<match_flag_type>(~static_cast<int>(b));
		}
		inline match_flag_type &operator&=(match_flag_type &left, const match_flag_type right)
		{
			left = left & right;
			return left;
		}
		inline match_flag_type &operator|=(match_flag_type &left, const match_flag_type right)
		{
			left = left | right;
			return left;
		}
		inline match_flag_type &operator^=(match_flag_type &left, const match_flag_type right)
		{
			left = left ^ right;
			return left;
		}
	}
	//  namespace regex_constants

	namespace regex_constants
	{
		typedef unsigned int error_type;

#define SRELLTMP_ET(n,v) SRELL_STACON error_type n = v;

		SRELLTMP_ET(error_collate, 100)
		SRELLTMP_ET(error_ctype, 101)
		SRELLTMP_ET(error_escape, 102)
		SRELLTMP_ET(error_backref, 103)
		SRELLTMP_ET(error_brack, 104)
		SRELLTMP_ET(error_paren, 105)
		SRELLTMP_ET(error_brace, 106)
		SRELLTMP_ET(error_badbrace, 107)
		SRELLTMP_ET(error_range, 108)
		SRELLTMP_ET(error_space, 109)
		SRELLTMP_ET(error_badrepeat, 110)
		SRELLTMP_ET(error_complexity, 111)
		SRELLTMP_ET(error_stack, 112)

		//  SRELL's extensions.
		SRELLTMP_ET(error_utf8, 113)
			//  The expression contained an invalid UTF-8 sequence.

		SRELLTMP_ET(error_property, 114)
			//  The expression contained an invalid Unicode property name or value.

		SRELLTMP_ET(error_noescape, 115)
			//  (Only in v-mode) ( ) [ ] { } / - \ | need to be escaped in a character class.

		SRELLTMP_ET(error_operator, 116)
			//  (Only in v-mode) A character class contained a reserved double punctuation
			//  operator or different types of operators at the same level, such as [ab--cd].

		SRELLTMP_ET(error_complement, 117)
			//  (Only in v-mode) \P or a negated character class contained a property of strings.

		SRELLTMP_ET(error_modifier, 118)
			//  A specific flag modifier appeared more then once, or the un-bounded form
			//  ((?ism-ism)) appeared at a position other than the beginning of the expression.

		SRELLTMP_ET(error_first_, error_collate)
		SRELLTMP_ET(error_last_, error_modifier)

#if defined(SRELL_FIXEDWIDTHLOOKBEHIND)
		SRELLTMP_ET(error_lookbehind, 200)
#endif

		SRELLTMP_ET(error_internal, 999)

#undef SRELLTMP_ET

	}
	//  namespace regex_constants

//  ... "regex_constants.h"]
//  ["rei_constants.h" ...

	namespace re_detail
	{
		enum re_state_type
		{
			st_character,               //  0x00
			st_characteri,              //  0x01
			st_character_class,         //  0x02

			st_epsilon,                 //  0x03

			st_check_counter,           //  0x04
			st_increment_counter,       //  0x05
			st_decrement_counter,       //  0x06
			st_save_and_reset_counter,  //  0x07
			st_restore_counter,         //  0x08

			st_roundbracket_open,       //  0x09
			st_roundbracket_pop,        //  0x0a
			st_roundbracket_close,      //  0x0b

			st_repeat_in_push,          //  0x0c
			st_repeat_in_pop,           //  0x0d
			st_check_0_width_repeat,    //  0x0e

			st_backreference,           //  0x0f

			st_lookaround_open,         //  0x10

			st_lookaround_pop,          //  0x11

			st_bol,                     //  0x12
			st_eol,                     //  0x13
			st_boundary,                //  0x14

			st_success,                 //  0x15

#if defined(SRELLTEST_NEXTPOS_OPT)
			st_move_nextpos,            //  0x16
#endif

			st_lookaround_close    = st_success,
			st_zero_width_boundary = st_lookaround_open
		};
		//  re_state_type

#define SRELLTMP_UIL32(n,v) SRELL_STACON ui_l32 n = v;

		namespace constants
		{
			SRELLTMP_UIL32(unicode_max_codepoint, 0x10ffff)
			SRELLTMP_UIL32(invalid_u32value, static_cast<ui_l32>(-1))
			SRELLTMP_UIL32(max_u32value, static_cast<ui_l32>(-2))
			SRELLTMP_UIL32(ccstr_empty, static_cast<ui_l32>(-1))
			SRELLTMP_UIL32(infinity, static_cast<ui_l32>(-1))
			SRELLTMP_UIL32(errshift, 24)
		}
		//  constants

		namespace masks
		{
			SRELLTMP_UIL32(asc_icase, 0x20)
			SRELLTMP_UIL32(cfolded, 0x200000)	//  1 << 21.
			SRELLTMP_UIL32(cf_char, 0x1fffff)
			SRELLTMP_UIL32(errmask, 0xff000000)
			SRELLTMP_UIL32(somask, 0xffffff)
		}
		//  masks

		namespace sflags
		{
			SRELLTMP_UIL32(is_not, 1)
			SRELLTMP_UIL32(icase, 1)
			SRELLTMP_UIL32(multiline, 1)
			SRELLTMP_UIL32(backrefno_unresolved, 1 << 1)
			SRELLTMP_UIL32(hooking, 1 << 2)
			SRELLTMP_UIL32(hookedlast, 1 << 3)
			SRELLTMP_UIL32(byn2, 1 << 4)
			SRELLTMP_UIL32(clrn2, 1 << 5)
		}
		//  sflags

		namespace meta_char
		{
			SRELLTMP_UIL32(mc_exclam, 0x21)	//  '!'
			SRELLTMP_UIL32(mc_sharp , 0x23)	//  '#'
			SRELLTMP_UIL32(mc_dollar, 0x24)	//  '$'
			SRELLTMP_UIL32(mc_rbraop, 0x28)	//  '('
			SRELLTMP_UIL32(mc_rbracl, 0x29)	//  ')'
			SRELLTMP_UIL32(mc_astrsk, 0x2a)	//  '*'
			SRELLTMP_UIL32(mc_plus  , 0x2b)	//  '+'
			SRELLTMP_UIL32(mc_comma , 0x2c)	//  ','
			SRELLTMP_UIL32(mc_minus , 0x2d)	//  '-'
			SRELLTMP_UIL32(mc_period, 0x2e)	//  '.'
			SRELLTMP_UIL32(mc_colon , 0x3a)	//  ':'
			SRELLTMP_UIL32(mc_lt, 0x3c)		//  '<'
			SRELLTMP_UIL32(mc_eq, 0x3d)		//  '='
			SRELLTMP_UIL32(mc_gt, 0x3e)		//  '>'
			SRELLTMP_UIL32(mc_query , 0x3f)	//  '?'
			SRELLTMP_UIL32(mc_sbraop, 0x5b)	//  '['
			SRELLTMP_UIL32(mc_escape, 0x5c)	//  '\\'
			SRELLTMP_UIL32(mc_sbracl, 0x5d)	//  ']'
			SRELLTMP_UIL32(mc_caret , 0x5e)	//  '^'
			SRELLTMP_UIL32(mc_cbraop, 0x7b)	//  '{'
			SRELLTMP_UIL32(mc_bar   , 0x7c)	//  '|'
			SRELLTMP_UIL32(mc_cbracl, 0x7d)	//  '}'
		}
		//  meta_char

		namespace char_ctrl
		{
			SRELLTMP_UIL32(cc_nul , 0x00)	//  '\0'	//0x00:NUL
			SRELLTMP_UIL32(cc_bs  , 0x08)	//  '\b'	//0x08:BS
			SRELLTMP_UIL32(cc_htab, 0x09)	//  '\t'	//0x09:HT
			SRELLTMP_UIL32(cc_nl  , 0x0a)	//  '\n'	//0x0a:LF
			SRELLTMP_UIL32(cc_vtab, 0x0b)	//  '\v'	//0x0b:VT
			SRELLTMP_UIL32(cc_ff  , 0x0c)	//  '\f'	//0x0c:FF
			SRELLTMP_UIL32(cc_cr  , 0x0d)	//  '\r'	//0x0d:CR
		}
		//  char_ctrl

		namespace char_alnum
		{
			SRELLTMP_UIL32(ch_0, 0x30)	//  '0'
			SRELLTMP_UIL32(ch_1, 0x31)	//  '1'
			SRELLTMP_UIL32(ch_9, 0x39)	//  '9'
			SRELLTMP_UIL32(ch_A, 0x41)	//  'A'
			SRELLTMP_UIL32(ch_B, 0x42)	//  'B'
			SRELLTMP_UIL32(ch_D, 0x44)	//  'D'
			SRELLTMP_UIL32(ch_P, 0x50)	//  'P'
			SRELLTMP_UIL32(ch_S, 0x53)	//  'S'
			SRELLTMP_UIL32(ch_W, 0x57)	//  'W'
			SRELLTMP_UIL32(ch_Z, 0x5a)	//  'Z'
			SRELLTMP_UIL32(ch_a, 0x61)	//  'a'
			SRELLTMP_UIL32(ch_b, 0x62)	//  'b'
			SRELLTMP_UIL32(ch_c, 0x63)	//  'c'
			SRELLTMP_UIL32(ch_d, 0x64)	//  'd'
			SRELLTMP_UIL32(ch_f, 0x66)	//  'f'
			SRELLTMP_UIL32(ch_i, 0x69)	//  'i'
			SRELLTMP_UIL32(ch_k, 0x6b)	//  'k'
			SRELLTMP_UIL32(ch_m, 0x6d)	//  'm'
			SRELLTMP_UIL32(ch_n, 0x6e)	//  'n'
			SRELLTMP_UIL32(ch_p, 0x70)	//  'p'
			SRELLTMP_UIL32(ch_q, 0x71)	//  'q'
			SRELLTMP_UIL32(ch_r, 0x72)	//  'r'
			SRELLTMP_UIL32(ch_s, 0x73)	//  's'
			SRELLTMP_UIL32(ch_t, 0x74)	//  't'
			SRELLTMP_UIL32(ch_u, 0x75)	//  'u'
			SRELLTMP_UIL32(ch_v, 0x76)	//  'v'
			SRELLTMP_UIL32(ch_w, 0x77)	//  'w'
			SRELLTMP_UIL32(ch_x, 0x78)	//  'x'
			SRELLTMP_UIL32(ch_y, 0x79)	//  'y'
			SRELLTMP_UIL32(ch_z, 0x7a)	//  'z'
		}
		//  char_alnum

		namespace char_other
		{
			SRELLTMP_UIL32(co_perc , 0x25)	//  '%'
			SRELLTMP_UIL32(co_amp  , 0x26)	//  '&'
			SRELLTMP_UIL32(co_apos , 0x27)	//  '\''
			SRELLTMP_UIL32(co_slash, 0x2f)	//  '/'
			SRELLTMP_UIL32(co_smcln, 0x3b)	//  ';'
			SRELLTMP_UIL32(co_atmrk, 0x40)	//  '@'
			SRELLTMP_UIL32(co_ll   , 0x5f)	//  '_'
			SRELLTMP_UIL32(co_grav , 0x60)	//  '`'
			SRELLTMP_UIL32(co_tilde, 0x7e)	//  '~'
		}
		//  char_other

		namespace epsilon_type	//  Used only in the pattern compiler.
		{
			SRELLTMP_UIL32(et_dfastrsk, 0x40)	//  '@'
			SRELLTMP_UIL32(et_ccastrsk, 0x2a)	//  '*'
			SRELLTMP_UIL32(et_alt     , 0x7c)	//  '|'
			SRELLTMP_UIL32(et_ncgopen , 0x3a)	//  ':'
			SRELLTMP_UIL32(et_ncgclose, 0x3b)	//  ';'
			SRELLTMP_UIL32(et_jmpinlp , 0x2b)	//  '+'
			SRELLTMP_UIL32(et_brnchend, 0x2f)	//  '/'
			SRELLTMP_UIL32(et_fmrbckrf, 0x5c)	//  '\\'
			SRELLTMP_UIL32(et_bo1fmrbr, 0x31)	//  '1'
			SRELLTMP_UIL32(et_bo2fmrbr, 0x32)	//  '2'
			SRELLTMP_UIL32(et_bo2skpd , 0x21)	//  '!'
			SRELLTMP_UIL32(et_rvfmrcg , 0x28)	//  '('
			SRELLTMP_UIL32(et_mfrfmrcg, 0x29)	//  ')'
			SRELLTMP_UIL32(et_aofmrast, 0x78)	//  'x'
		}
		//  epsilon_type

#undef SRELLTMP_UIL32

	}
	//  namespace re_detail

//  ... "rei_constants.h"]
//  ["regex_error.hpp" ...

class regex_error : public std::runtime_error
{
public:

	explicit regex_error(const regex_constants::error_type ecode)
		: std::runtime_error(what_(ecode))
		, ecode_(ecode)
	{
	}

	regex_constants::error_type code() const
	{
		return ecode_;
	}

private:

	static const char *what_(const regex_constants::error_type e)
	{
		static const char *enames[] = {
			"error_collate", "error_ctype", "error_escape", "error_backref", "error_brack"
			, "error_paren", "error_brace", "error_badbrace", "error_range", "error_space"
			, "error_badrepeat", "error_complexity", "error_stack"	//  13.
			, "error_utf8", "error_property", "error_noescape", "error_operator", "error_complement"
			, "error_modifier"	//  +6.
			, "", "error_internal", "error_lookbehind"
		};
		const regex_constants::error_type num = regex_constants::error_last_ - regex_constants::error_first_ + 1;

		return enames[e == 0
			? num
			: ((e - regex_constants::error_first_) < num
				? (e - regex_constants::error_first_)
				: (num + (e == 200 ? 2 : 1)))];
	}

	regex_constants::error_type ecode_;
};

//  ... "regex_error.hpp"]
//  ["rei_utf_traits.hpp" ...

	namespace re_detail
	{

#if defined(_MSC_VER)
#define SRELL_FORCEINLINE __forceinline
#elif defined(__GNUC__)
#define SRELL_FORCEINLINE __attribute__((always_inline))
#else
#define SRELL_FORCEINLINE
#endif

template <typename charT>
struct utf_traits_core
{
public:

	typedef charT char_type;

	enum
	{
		maxseqlen = 1,
		cb_ = sizeof (charT) == 1 ? CHAR_BIT : std::numeric_limits<charT>::digits,
		charbit = cb_ < 21 ? cb_ : 21,
		bitsetsize = 1 << charbit,
		bitsetmask = bitsetsize - 1,
		maxcpvalue = charbit < 21 ? bitsetmask : 0x10ffff,
		ecmask = charbit < 21 ? (bitsetsize << 1) - 1 : bitsetmask
	};

	//  *iter++
	template <typename ForwardIterator>
	static ui_l32 codepoint_inc(ForwardIterator &begin, const ForwardIterator /* end */)
	{
		return static_cast<ui_l32>(*begin++);
		//  Caller is responsible for begin != end.
	}

	//  *--iter
	template <typename BidirectionalIterator>
	static ui_l32 dec_codepoint(BidirectionalIterator &cur, const BidirectionalIterator /* begin */)
	{
		return static_cast<ui_l32>(*--cur);
		//  Caller is responsible for cur != begin.
	}

	template <typename I>	//  ui_l32 or char_type2.
	static bool is_mculeading(const I)
	{
		return false;
	}

	template <typename charT2>
	static bool is_trailing(const charT2 /* cu */)
	{
		return false;
	}

	static ui_l32 to_codeunits(charT out[maxseqlen], ui_l32 cp)
	{
		out[0] = static_cast<charT>(cp);
		return 1;
	}

	static ui_l32 seqlen(const ui_l32)
	{
		return 1;
	}

	static ui_l32 firstcodeunit(const ui_l32 cp)
	{
		return cp;
	}

	static ui_l32 nextlengthchange(const ui_l32)
	{
		return static_cast<ui_l32>(maxcpvalue + 1);
	}
};
//  utf_traits_core

//  common and utf-32.
template <typename charT>
struct utf_traits : public utf_traits_core<charT>
{
};
//  utf_traits

//  utf-8 specific.
template <typename charT>
struct utf8_traits : public utf_traits_core<charT>
{
public:

	enum
	{
		maxseqlen = 4,
		bitsetsize = 0x100,
		bitsetmask = 0xff,
		maxcpvalue = 0x10ffff
	};

	template <typename ForwardIterator>
	static SRELL_FORCEINLINE ui_l32 codepoint_inc(ForwardIterator &begin, const ForwardIterator end)
	{
		ui_l32 codeunits = static_cast<ui_l32>(*begin++ & 0xff);

		if ((codeunits & 0x80) == 0)
			return codeunits;

		if (begin != end)
		{
//			codeunits = static_cast<ui_l32>((codeunits << 6) | _pdep_u32(*begin, 0xc03f));
			codeunits = static_cast<ui_l32>((*begin & 0x3f) | ((*begin & 0xc0) << 8) | (codeunits << 6));
			++begin;

			//  1011 0aaa aabb bbbb?
			if ((codeunits - 0xb080) < 0x780)
				return static_cast<ui_l32>(codeunits & 0x7ff);

			if (begin != end)
			{
				codeunits = static_cast<ui_l32>((*begin & 0x3f) | ((*begin & 0xc0) << 16) | (codeunits << 6));
				++begin;

				//  1010 1110 aaaa bbbb bbcc cccc?
				if ((codeunits - 0xae0800) < 0xf800)
					return static_cast<ui_l32>(codeunits & 0xffff);

				if (begin != end)
				{
					codeunits = static_cast<ui_l32>((*begin & 0x3f) | ((*begin & 0xc0) << 24) | (codeunits << 6));
					++begin;

					//  1010 1011 110a aabb bbbb cccc ccdd dddd?
					if ((codeunits - 0xabc10000) < 0x100000)
						return static_cast<ui_l32>(codeunits & 0x1fffff);
				}
			}
		}
		return re_detail::constants::invalid_u32value;
	}

	template <typename BidirectionalIterator>
	static SRELL_FORCEINLINE ui_l32 dec_codepoint(BidirectionalIterator &cur, const BidirectionalIterator begin)
	{
		ui_l32 codeunits = static_cast<ui_l32>(*--cur);

		if ((codeunits & 0x80) == 0)
			return static_cast<ui_l32>(codeunits & 0xff);

		if (cur != begin)
		{
			codeunits = static_cast<ui_l32>((codeunits & 0x3f) | ((codeunits & 0xc0) << 8) | ((*--cur & 0xff) << 6));

			//  1011 0bbb bbaa aaaa?
			if ((codeunits - 0xb080) < 0x780)
				return static_cast<ui_l32>(codeunits & 0x7ff);

			if (cur != begin)
			{
				codeunits = static_cast<ui_l32>((codeunits & 0xfff) | ((codeunits & 0xf000) << 8) | ((*--cur & 0xff) << 12));

				//  1010 1110 cccc bbbb bbaa aaaa?
				if ((codeunits - 0xae0800) < 0xf800)
					return static_cast<ui_l32>(codeunits & 0xffff);

				if (cur != begin)
				{
					codeunits = static_cast<ui_l32>((codeunits & 0x3ffff) | ((codeunits & 0xfc0000) << 8) | ((*--cur & 0xff) << 18));

					//  1010 1011 110d ddcc cccc bbbb bbaa aaaa?
					if ((codeunits - 0xabc10000) < 0x100000)
						return static_cast<ui_l32>(codeunits & 0x1fffff);
				}
			}
		}
		return re_detail::constants::invalid_u32value;
	}

	template <typename I>
	static bool is_mculeading(const I c)
	{
		return (c & 0x80) ? true : false;
	}

	template <typename charT2>
	static bool is_trailing(const charT2 cu)
	{
		return (cu & 0xc0) == 0x80;
	}

	static ui_l32 to_codeunits(charT out[maxseqlen], ui_l32 cp)
	{
		if (cp < 0x80)
		{
			out[0] = static_cast<charT>(cp);
			return 1;
		}
		else if (cp < 0x800)
		{
			out[0] = static_cast<charT>(((cp >> 6) & 0x1f) | 0xc0);
			out[1] = static_cast<charT>((cp & 0x3f) | 0x80);
			return 2;
		}
		else if (cp < 0x10000)
		{
			out[0] = static_cast<charT>(((cp >> 12) & 0x0f) | 0xe0);
			out[1] = static_cast<charT>(((cp >> 6) & 0x3f) | 0x80);
			out[2] = static_cast<charT>((cp & 0x3f) | 0x80);
			return 3;
		}

		out[0] = static_cast<charT>(((cp >> 18) & 0x07) | 0xf0);
		out[1] = static_cast<charT>(((cp >> 12) & 0x3f) | 0x80);
		out[2] = static_cast<charT>(((cp >> 6) & 0x3f) | 0x80);
		out[3] = static_cast<charT>((cp & 0x3f) | 0x80);
		return 4;
	}

	static ui_l32 seqlen(const ui_l32 cp)
	{
		return (cp < 0x80) ? 1 : ((cp < 0x800) ? 2 : ((cp < 0x10000) ? 3 : 4));
	}

	static ui_l32 firstcodeunit(const ui_l32 cp)
	{
		if (cp < 0x80)
			return cp;

		if (cp < 0x800)
			return static_cast<ui_l32>(((cp >> 6) & 0x1f) | 0xc0);

		if (cp < 0x10000)
			return static_cast<ui_l32>(((cp >> 12) & 0x0f) | 0xe0);

		return static_cast<ui_l32>(((cp >> 18) & 0x07) | 0xf0);
	}

	static ui_l32 nextlengthchange(const ui_l32 cp)
	{
		return (cp < 0x80) ? 0x80 : ((cp < 0x800) ? 0x800 : ((cp < 0x10000) ? 0x10000 : 0x110000));
	}
};
//  utf8_traits

//  utf-16 specific.
template <typename charT>
struct utf16_traits : public utf_traits_core<charT>
{
public:

	enum
	{
		maxseqlen = 2,
		bitsetsize = 0x10000,
		bitsetmask = 0xffff,
		maxcpvalue = 0x10ffff
	};

	template <typename ForwardIterator>
	static SRELL_FORCEINLINE ui_l32 codepoint_inc(ForwardIterator &begin, const ForwardIterator end)
	{
		const ui_l32 codeunit = static_cast<ui_l32>(*begin++);

		if ((codeunit & 0xfc00) != 0xd800)
			return static_cast<ui_l32>(codeunit & 0xffff);

		if (begin != end && (*begin & 0xfc00) == 0xdc00)
			return static_cast<ui_l32>((((codeunit & 0x3ff) << 10) | (*begin++ & 0x3ff)) + 0x10000);

		return static_cast<ui_l32>(codeunit & 0xffff);
	}

	template <typename BidirectionalIterator>
	static SRELL_FORCEINLINE ui_l32 dec_codepoint(BidirectionalIterator &cur, const BidirectionalIterator begin)
	{
		const ui_l32 codeunit = static_cast<ui_l32>(*--cur);

		if ((codeunit & 0xfc00) != 0xdc00 || cur == begin)
			return static_cast<ui_l32>(codeunit & 0xffff);

		if ((*--cur & 0xfc00) == 0xd800)
			return static_cast<ui_l32>((((*cur & 0x3ff) << 10) | (codeunit & 0x3ff)) + 0x10000);

		++cur;

		return static_cast<ui_l32>(codeunit & 0xffff);
	}

	template <typename I>
	static bool is_mculeading(const I c)
	{
		return (c & 0xfc00) == 0xd800;
	}

	template <typename charT2>
	static bool is_trailing(const charT2 cu)
	{
		return (cu & 0xfc00) == 0xdc00;
	}

	static ui_l32 to_codeunits(charT out[maxseqlen], ui_l32 cp)
	{
		if (cp < 0x10000)
		{
			out[0] = static_cast<charT>(cp);
			return 1;
		}

		cp -= 0x10000;
		out[0] = static_cast<charT>(((cp >> 10) & 0x3ff) | 0xd800);
		out[1] = static_cast<charT>((cp & 0x3ff) | 0xdc00);
		return 2;
	}

	static ui_l32 seqlen(const ui_l32 cp)
	{
		return (cp < 0x10000) ? 1 : 2;
	}

	static ui_l32 firstcodeunit(const ui_l32 cp)
	{
		if (cp < 0x10000)
			return cp;

		return static_cast<ui_l32>((cp >> 10) + 0xd7c0);
			//  aaaaa bbbbcccc ddddeeee -> AA AAbb bbcc/cc dddd eeee where AAAA = aaaaa - 1.
	}

	static ui_l32 nextlengthchange(const ui_l32 cp)
	{
		return (cp < 0x10000) ? 0x10000 : 0x110000;
	}
};
//  utf16_traits

//  specialisation for char.
template <>
struct utf_traits<char> : public utf_traits_core<char>
{
public:

	template <typename ForwardIterator>
	static ui_l32 codepoint_inc(ForwardIterator &begin, const ForwardIterator /* end */)
	{
		return static_cast<ui_l32>(static_cast<unsigned char>(*begin++));
	}

	template <typename BidirectionalIterator>
	static ui_l32 dec_codepoint(BidirectionalIterator &cur, const BidirectionalIterator /* begin */)
	{
		return static_cast<ui_l32>(static_cast<unsigned char>(*--cur));
	}
};	//  utf_traits<char>

//  specialisation for signed char.
template <>
struct utf_traits<signed char> : public utf_traits<char>
{
};

//  (signed) short, (signed) int, (signed) long, (signed) long long, ...

#if defined(__cpp_unicode_characters)
template <>
struct utf_traits<char16_t> : public utf16_traits<char16_t>
{
};
#endif

#if defined(__cpp_char8_t)
template <>
struct utf_traits<char8_t> : public utf8_traits<char8_t>
{
};
#endif

	}	//  re_detail

//  ... "rei_utf_traits.hpp"]
//  ["regex_traits.hpp" ...

template <class charT>
struct regex_traits
{
public:

	typedef charT char_type;
	typedef std::basic_string<char_type> string_type;
	typedef int locale_type;
	typedef int char_class_type;

	typedef re_detail::utf_traits<charT> utf_traits;
};	//  regex_traits

template <class charT>
struct u8regex_traits : public regex_traits<charT>
{
	typedef re_detail::utf8_traits<charT> utf_traits;
};

template <class charT>
struct u16regex_traits : public regex_traits<charT>
{
	typedef re_detail::utf16_traits<charT> utf_traits;
};

//  ... "regex_traits.hpp"]
//  ["rei_memory.hpp" ...

	namespace re_detail
	{

template <typename charT>
struct concon_view
{
	typedef std::size_t size_type;

	const charT *data_;
	size_type size_;

	template <typename ContiguousContainer>
	concon_view(const ContiguousContainer &c)
//		requires std::contiguous_iterator<typename ContiguousContainer::iterator>
		: data_(c.data()), size_(c.size()) {}

	concon_view() : data_(NULL), size_(0) {}
	concon_view(const charT *const p, const size_type s) : data_(p), size_(s) {}

	const charT *data() const
	{
		return data_;
	}
	size_type size() const
	{
		return size_;
	}
};
// concon_view

template <typename ElemT>
class simple_array
{
public:

	typedef ElemT value_type;
	typedef std::size_t size_type;
	typedef ElemT &reference;
	typedef const ElemT &const_reference;
	typedef ElemT *pointer;
	typedef const ElemT *const_pointer;
	typedef concon_view<ElemT> sa_view;

	static const size_type npos = static_cast<size_type>(-1);

public:

	simple_array()
		: buffer_(NULL), size_(0), capacity_(0)
	{
	}

	simple_array(const size_type initsize)
		: buffer_(static_cast<pointer>(std::malloc(initsize * sizeof (ElemT)))), size_(initsize), capacity_(initsize)
	{
		if (buffer_ == NULL)
			throw std::bad_alloc();
	}

	simple_array(const simple_array &right)
		: buffer_(NULL), size_(0), capacity_(0)
	{
		operator=(right);
	}

	simple_array(const sa_view &v)
		: buffer_(NULL), size_(0), capacity_(0)
	{
		operator=(v);
	}

	simple_array &operator=(const simple_array &right)
	{
		if (this != &right)
		{
			resize(right.size_);
			if (right.size_)
				std::memmove(buffer_, right.buffer_, right.size_ * sizeof (ElemT));
		}
		return *this;
	}

	simple_array &operator=(const sa_view &v)
	{
		if (buffer_ != v.data_)
		{
			resize(v.size_);
			if (v.size_)
				std::memmove(buffer_, v.data_, v.size_ * sizeof (ElemT));
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	simple_array(simple_array &&right) SRELL_NOEXCEPT
		: buffer_(right.buffer_)
		, size_(right.size_)
		, capacity_(right.capacity_)
	{
		right.size_ = 0;
		right.capacity_ = 0;
		right.buffer_ = NULL;
	}

	simple_array &operator=(simple_array &&right) SRELL_NOEXCEPT
	{
		if (this != &right)
		{
			if (this->buffer_ != NULL)
				std::free(this->buffer_);

			this->size_ = right.size_;
			this->capacity_ = right.capacity_;
			this->buffer_ = right.buffer_;

			right.size_ = 0;
			right.capacity_ = 0;
			right.buffer_ = NULL;
		}
		return *this;
	}
#endif

	~simple_array()
	{
		if (buffer_ != NULL)
			std::free(buffer_);
	}

	size_type size() const
	{
		return size_;
	}

	bool operator==(const simple_array &right) const
	{
		if (this->size_ != right.size_)
			return false;

		for (size_type i = 0; i < size_; ++i)
			if (this->buffer_[i] != right[i])
				return false;

		return true;
	}

	void clear()
	{
		size_ = 0;
	}

	void reset()
	{
		if (size_)
			std::memset(buffer_, 0, size_ * sizeof (ElemT));
	}

	void resize(const size_type newsize)
	{
		if (newsize > capacity_)
			reserve_<16>(newsize);

		size_ = newsize;
	}

	void resize(const size_type newsize, const ElemT &type)
	{
		size_type oldsize = size_;

		resize(newsize);
		for (; oldsize < size_; ++oldsize)
			buffer_[oldsize] = type;
	}

	void shrink(const size_type newsize)
	{
		size_ = newsize;
	}

	reference operator[](const size_type pos)
	{
		return buffer_[pos];
	}

	const_reference operator[](const size_type pos) const
	{
		return buffer_[pos];
	}

	void push_back(const_reference n)
	{
		const size_type oldsize = size_;

		if (++size_ > capacity_)
			reserve_<16>(size_);

		buffer_[oldsize] = n;
	}

	void push_back_c(const ElemT e)
	{
		push_back(e);
	}

	const_reference back() const
	{
		return buffer_[size_ - 1];
	}

	reference back()
	{
		return buffer_[size_ - 1];
	}

	void pop_back()
	{
		--size_;
	}

	void assign(const const_pointer p, const size_type len)
	{
		if (p != buffer_)
		{
			resize(len);
			if (len)
				std::memmove(buffer_, p, len * sizeof (ElemT));
		}
	}

	simple_array &append(const size_type size, const ElemT &type)
	{
		resize(size_ + size, type);
		return *this;
	}

	simple_array &append(const const_pointer p, const size_type size)
	{
		if (size)
		{
			resize(size_ + size);
			std::memmove(buffer_ + size_ - size, p, size * sizeof (value_type));
		}
		return *this;
	}

	simple_array &append(const simple_array &right)
	{
		const size_type rightsize = right.size_;

		if (rightsize)
		{
			const size_type oldsize = size_;

			resize(size_ + right.size_);
			std::memmove(buffer_ + oldsize, right.buffer_, rightsize * sizeof (ElemT));
		}
		return *this;
	}

	simple_array &append(const simple_array &right, const size_type pos, size_type len)
	{
		if (len)
		{
			const size_type oldsize = size_;

			resize(size_ + len);
			std::memmove(buffer_ + oldsize, right.buffer_ + pos, len * sizeof (ElemT));
		}
		return *this;
	}

	void erase(const size_type pos)
	{
		if (pos < size_)
		{
			std::memmove(buffer_ + pos, buffer_ + pos + 1, (size_ - pos - 1) * sizeof (ElemT));
			--size_;
		}
	}
	void erase(const size_type pos, const size_type len)
	{
		if (pos < size_)
		{
			size_type rmndr = size_ - pos;

			if (rmndr > len)
			{
				rmndr -= len;
				std::memmove(buffer_ + pos, buffer_ + pos + len, rmndr * sizeof (ElemT));
				size_ -= len;
			}
			else
				size_ = pos;
		}
	}

	//  For rei_compiler class.
	void insert(const size_type pos, const ElemT &type)
	{
		move_forwards_(pos, 1);
		buffer_[pos] = type;
	}

	void insert(const size_type pos, const simple_array &right)
	{
		if (right.size_)
		{
			move_forwards_(pos, right.size_);
			std::memmove(buffer_ + pos, right.buffer_, right.size_ * sizeof (ElemT));
		}
	}

	void insert(const size_type destpos, const simple_array &right, size_type srcpos, size_type srclen = npos)
	{
		{
			const size_type len2 = right.size_ - srcpos;
			if (srclen > len2)
				srclen = len2;
		}

		if (srclen)
		{
			move_forwards_(destpos, srclen);
			std::memmove(buffer_ + destpos, right.buffer_ + srcpos, srclen * sizeof (ElemT));
		}
	}

	simple_array &replace(const size_type pos, size_type count, const simple_array &right)
	{
		if (count < right.size_)
			move_forwards_(pos + count, right.size_ - count);
		else if (count > right.size_)
		{
			const size_type rmndr = size_ - pos - count;

			if (rmndr)
			{
				const pointer base = buffer_ + pos;

				std::memmove(base + right.size_, base + count, rmndr * sizeof (ElemT));
			}
			size_ -= count - right.size_;
		}

		if (right.size_)
			std::memmove(buffer_ + pos, right.buffer_, right.size_ * sizeof (ElemT));
		return *this;
	}

	size_type find(const value_type c, size_type pos = 0) const
	{
		for (; pos <= size_; ++pos)
			if (buffer_[pos] == c)
				return pos;

		return npos;
	}

	void reverse()
	{
		const size_type half = size_ >> 1;

		for (size_type i = 0; i < half; ++i)
		{
			const ElemT tmp = buffer_[i];
			ElemT &r = buffer_[size_ - i - 1];
			buffer_[i] = r;
			r = tmp;
		}
	}

	size_type max_size() const
	{
		return maxsize_;
	}

	const_pointer data() const
	{
		return buffer_;
	}

	void swap(simple_array &right)
	{
		if (this != &right)
		{
			const pointer tmpbuffer = this->buffer_;
			const size_type tmpsize = this->size_;
			const size_type tmpcapacity = this->capacity_;

			this->buffer_ = right.buffer_;
			this->size_ = right.size_;
			this->capacity_ = right.capacity_;

			right.buffer_ = tmpbuffer;
			right.size_ = tmpsize;
			right.capacity_ = tmpcapacity;
		}
	}

protected:

	template <const size_type minsize>
	void reserve_(size_type newsize)
	{
		if (newsize <= maxsize_)
		{
			const pointer oldbuffer = buffer_;
			const size_type capa2 = newsize >= minsize ? capacity_ << 1 : minsize;

			if (newsize < capa2)
			{
				newsize = capa2;
				if (newsize > maxsize_)
					newsize = maxsize_;
			}

			buffer_ = static_cast<pointer>(std::realloc(buffer_, newsize * sizeof (ElemT)));
			capacity_ = newsize;

			if (buffer_ != NULL)
				return;

			std::free(oldbuffer);
//			buffer_ = NULL;
			size_ = capacity_ = 0;
		}
		throw std::bad_alloc();
	}

	void move_forwards_(const size_type pos, const size_type count)
	{
		const size_type oldsize = size_;

		resize(size_ + count);

		if (pos < oldsize)
		{
			const pointer base = buffer_ + pos;

			std::memmove(base + count, base, (oldsize - pos) * sizeof (ElemT));
		}
	}

protected:

	pointer buffer_;
	size_type size_;
	size_type capacity_;

	SRELL_STACON size_type maxsize_ = npos / sizeof (ElemT) / 2;
};
template <typename ElemT>
const typename simple_array<ElemT>::size_type simple_array<ElemT>::npos;
//  simple_array

typedef simple_array<ui_l32> u32array;
typedef concon_view<ui_l32> u32view;
typedef u32array::size_type u32size_type;

struct simple_stack : protected simple_array<char>
{
	using simple_array<char>::size_type;
	using simple_array<char>::clear;
	using simple_array<char>::size;
	using simple_array<char>::shrink;

	template <typename T>
	void push_back_t_nc(const T &n)
	{
		std::memcpy(buffer_ + size_, &n, sizeof (T));
		size_ += sizeof (T);
	}

	template <typename T>
	void push_back_t(const T &n)
	{
		const size_type newsize = size_ + sizeof (T);

		if (newsize > capacity_)
			reserve_<256>(newsize);

		std::memcpy(buffer_ + size_, &n, sizeof (T));
		size_ = newsize;
	}

	template <typename T>
	void pop_back_t(T &t)
	{
		size_ -= sizeof (T);
		std::memcpy(&t, buffer_ + size_, sizeof (T));
	}

	void expand(const size_type add)
	{
		const size_type newsize = size_ + add;

		if (newsize > capacity_)
			reserve_<256>(newsize);
	}
};
//  simple_stack

	}	//  namespace re_detail

//  ... "rei_memory.hpp"]
//  ["rei_bitset.hpp" ...

	namespace re_detail
	{

template <const std::size_t Bits>
struct bitsetbase
{
	typedef std::size_t array_type;

#if defined(__cpp_constexpr)
	static constexpr std::size_t find_maxpow2(const array_type v, const std::size_t p2)
	{
		return v == 0 ? (p2 >> 1) : find_maxpow2((v << (p2 - 1)) << 1, p2 << 1);
	}
	static constexpr std::size_t bits_per_elem_ = find_maxpow2(0x80000000, 32);
#else
	SRELL_STACON array_type maxval_ = static_cast<array_type>(-1);
	SRELL_STACON std::size_t bits_per_elem_ = (((maxval_ >> 31) >> 31) >> 1) ? 64 : 32;
#endif
};

template <>
struct bitsetbase<256>
{
	typedef unsigned char array_type;

	SRELL_STACON std::size_t bits_per_elem_ = 1;
};

template <const std::size_t Bits>
class bitset : private bitsetbase<Bits>
{
	typedef bitsetbase<Bits> base_type;
	typedef typename base_type::array_type array_type;

public:

	bitset()
		: buffer_(static_cast<array_type *>(std::malloc(size_in_byte_)))
	{
		if (buffer_ != NULL)
		{
			reset();
			return;
		}
		throw std::bad_alloc();
	}

	bitset(const bitset &right)
		: buffer_(static_cast<array_type *>(std::malloc(size_in_byte_)))
	{
		if (buffer_ != NULL)
		{
			operator=(right);
			return;
		}
		throw std::bad_alloc();
	}

#if defined(__cpp_rvalue_references)
	bitset(bitset &&right) SRELL_NOEXCEPT
		: buffer_(right.buffer_)
	{
		right.buffer_ = NULL;
	}
#endif

	bitset &operator=(const bitset &right)
	{
		if (this != &right)
		{
			std::memcpy(buffer_, right.buffer_, size_in_byte_);
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	bitset &operator=(bitset &&right) SRELL_NOEXCEPT
	{
		if (this != &right)
		{
			if (this->buffer_ != NULL)
				std::free(this->buffer_);

			this->buffer_ = right.buffer_;
			right.buffer_ = NULL;
		}
		return *this;
	}
#endif

	~bitset()
	{
		if (buffer_ != NULL)
			std::free(buffer_);
	}

	bitset &reset()
	{
		std::memset(buffer_, 0, size_in_byte_);
		return *this;
	}

	bitset &reset(const std::size_t bit)
	{
		buffer_[bit / base_type::bits_per_elem_] &= ~(static_cast<array_type>(1) << (bit & bitmask_));
		return *this;
	}

	bitset &set(const std::size_t bit)
	{
		buffer_[bit / base_type::bits_per_elem_] |= (static_cast<array_type>(1) << (bit & bitmask_));
		return *this;
	}

	bool test(const std::size_t bit) const
	{
		return ((buffer_[bit / base_type::bits_per_elem_] >> (bit & bitmask_)) & 1) != 0;
	}

	void swap(bitset &right)
	{
		if (this != &right)
		{
			array_type *const tmpbuffer = this->buffer_;
			this->buffer_ = right.buffer_;
			right.buffer_ = tmpbuffer;
		}
	}

private:

	SRELL_STACON std::size_t bitmask_ = base_type::bits_per_elem_ - 1;
	SRELL_STACON std::size_t arraylength_ = (Bits + bitmask_) / base_type::bits_per_elem_;
	SRELL_STACON std::size_t size_in_byte_ = arraylength_ * sizeof (array_type);

	array_type *buffer_;
};

	}	//  namespace re_detail

//  ... "rei_bitset.hpp"]
//  ["rei_ucf.hpp" ...

	namespace re_detail
	{

#if !defined(SRELL_NO_UNICODE_ICASE)

		namespace ucf_constants
		{

#include "srell_ucfdata2.h"

		}	//  namespace ucf_constants

		namespace ucf_internal
		{

typedef ucf_constants::unicode_casefolding<ui_l32, ui_l32> ucfdata;

		}	//  namespace ucf_internal
#endif	//  !defined(SRELL_NO_UNICODE_ICASE)

		namespace ucf_constants
		{
#if !defined(SRELL_NO_UNICODE_ICASE)
			static const ui_l32 rev_maxset = ucf_internal::ucfdata::rev_maxset;
			static const ui_l32 rev_maxcp = ucf_internal::ucfdata::rev_maxcodepoint;
#else
			static const ui_l32 rev_maxset = 2;
			static const ui_l32 rev_maxcp = char_alnum::ch_z;
#endif
		}	//  namespace ucf_constants

class unicode_case_folding
{
public:

	static ui_l32 do_casefolding(const ui_l32 cp)
	{
#if !defined(SRELL_NO_UNICODE_ICASE)
		if (cp <= ucf_internal::ucfdata::ucf_maxcodepoint)
			return cp + ucf_internal::ucfdata::ucf_deltatable[ucf_internal::ucfdata::ucf_segmenttable[cp >> 8] + (cp & 0xff)];
#else
		if (cp >= char_alnum::ch_A && cp <= char_alnum::ch_Z)	//  'A' && 'Z'
			return static_cast<ui_l32>(cp - char_alnum::ch_A + char_alnum::ch_a);	//  - 'A' + 'a'
#endif
		return cp;
	}

	static ui_l32 do_caseunfolding(ui_l32 out[ucf_constants::rev_maxset], const ui_l32 cp)
	{
#if !defined(SRELL_NO_UNICODE_ICASE)
		ui_l32 count = 0u;

		if (cp <= ucf_internal::ucfdata::rev_maxcodepoint)
		{
			const ui_l32 offset_of_charset = ucf_internal::ucfdata::rev_indextable[ucf_internal::ucfdata::rev_segmenttable[cp >> 8] + (cp & 0xff)];
			const ui_l32 *ptr = &ucf_internal::ucfdata::rev_charsettable[offset_of_charset];

			for (; *ptr != cfcharset_eos_ && count < ucf_constants::rev_maxset; ++ptr, ++count)
				out[count] = *ptr;
		}
		if (count == 0u)
			out[count++] = cp;

		return count;
#else
		const ui_l32 nocase = static_cast<ui_l32>(cp | masks::asc_icase);

		out[0] = cp;
		if (nocase >= char_alnum::ch_a && nocase <= char_alnum::ch_z)
		{
			out[1] = static_cast<ui_l32>(cp ^ masks::asc_icase);
			return 2u;
		}
		return 1u;
#endif
	}

	static ui_l32 try_casefolding(const ui_l32 cp)
	{
#if !defined(SRELL_NO_UNICODE_ICASE)
		if (cp <= ucf_internal::ucfdata::rev_maxcodepoint)
		{
			const ui_l32 offset_of_charset = ucf_internal::ucfdata::rev_indextable[ucf_internal::ucfdata::rev_segmenttable[cp >> 8] + (cp & 0xff)];
			const ui_l32 uf0 = ucf_internal::ucfdata::rev_charsettable[offset_of_charset];

			return uf0 != cfcharset_eos_ ? uf0 : constants::invalid_u32value;
		}
#else
		const ui_l32 nocase = static_cast<ui_l32>(cp | masks::asc_icase);

		if (nocase >= char_alnum::ch_a && nocase <= char_alnum::ch_z)
			return nocase;
#endif
		return constants::invalid_u32value;
	}

private:

#if !defined(SRELL_NO_UNICODE_ICASE)
	static const ui_l32 cfcharset_eos_ = ucf_internal::ucfdata::eos;
#endif

public:	//  For debug.

	void print_tables() const;
};
//  unicode_case_folding

	}	//  namespace re_detail

//  ... "rei_ucf.hpp"]
//  ["rei_up.hpp" ...

	namespace re_detail
	{

#if !defined(SRELL_NO_UNICODE_PROPERTY)

		namespace up_constants
		{

#include "srell_updata3.h"

			SRELL_STACON ui_l32 error_property = static_cast<ui_l32>(-1);
		}	//  namespace up_constants

		namespace up_internal
		{
			typedef int up_type;
			typedef const char *pname_type;

			struct pnameno_map_type
			{
				pname_type name;
				up_type pno;
			};

			struct posinfo
			{
				ui_l32 offset;
				ui_l32 numofpairs;
			};

			typedef up_constants::unicode_property_data<
				pnameno_map_type,
				posinfo,
				ui_l32
				> updata;

		}	//  namespace up_internal

class unicode_property
{
public:

	typedef simple_array<char> pstring;

	static ui_l32 lookup_property(const u32view name, const u32view value)
	{
		up_type ptype = name.size_ > 0 ? lookup_property_name(name) : up_constants::uptype_gc;
		const posinfo *pos = &updata::positiontable[ptype];
		ui_l32 pno = lookup_property_value(value, pos->offset, pos->numofpairs);

		if (pno == upid_error && name.size() < 2)
		{
			ptype = up_constants::uptype_bp;
			pos = &updata::positiontable[ptype];
			pno = lookup_property_value(value, pos->offset, pos->numofpairs);
		}

		return pno != upid_error ? pno : up_constants::error_property;
	}

	static ui_l32 ranges_offset(const ui_l32 property_number)
	{
		return updata::positiontable[property_number].offset;
	}

	static ui_l32 number_of_ranges(const ui_l32 property_number)
	{
		return updata::positiontable[property_number].numofpairs;
	}

	static const ui_l32 *ranges_address(const ui_l32 pno)
	{
		return &updata::rangetable[ranges_offset(pno) << 1];
	}

	static bool is_valid_pno(const ui_l32 pno)
	{
		return pno != up_constants::error_property && pno <= max_property_number;
	}

	static bool is_pos(const ui_l32 pno)
	{
		return pno > max_property_number && pno <= max_pos_number;
	}

private:

	typedef up_internal::up_type up_type;
	typedef up_internal::pname_type pname_type;
	typedef up_internal::pnameno_map_type pnameno_map_type;
	typedef up_internal::posinfo posinfo;
	typedef up_internal::updata updata;

	static up_type lookup_property_name(const u32view name)
	{
		return lookup_property_value(name, 1, updata::propertynumbertable[0].pno);
	}

	static ui_l32 lookup_property_value(const u32view value, const ui_l32 offset, ui_l32 count)
	{
		const pnameno_map_type *base = &updata::propertynumbertable[offset];

		while (count)
		{
			ui_l32 mid = count >> 1;
			const pnameno_map_type &map = base[mid];
			const int cmp = compare(value, map.name);

			if (cmp < 0)
			{
				count = mid;
			}
			else if (cmp > 0)
			{
				++mid;
				count -= mid;
				base += mid;
			}
			else	//if (cmp == 0)
				return static_cast<ui_l32>(map.pno);
		}
		return upid_error;
	}

	static int compare(const u32view value, pname_type pname)
	{
		for (u32view::size_type i = 0;; ++i, ++pname)
		{
			if (i == value.size_)
				return (*pname == 0) ? 0 : -1;

			if (value.data_[i] != static_cast<ui_l32>(*pname))
				return value.data_[i] < static_cast<ui_l32>(*pname) ? -1 : 1;
		}
	}

private:

	static const ui_l32 max_property_number = static_cast<ui_l32>(up_constants::upid_max_property_number);
	static const ui_l32 max_pos_number = static_cast<ui_l32>(up_constants::upid_max_pos_number);
#if (SRELL_UPDATA_VERSION > 300)
	static const ui_l32 upid_error = static_cast<ui_l32>(up_constants::upid_error);
#else
	static const ui_l32 upid_error = static_cast<ui_l32>(up_constants::upid_unknown);
#endif
};
//  unicode_property

#endif	//  !defined(SRELL_NO_UNICODE_PROPERTY)
	}	//  namespace re_detail

//  ... "rei_up.hpp"]
//  ["rei_range_pair.hpp" ...

	namespace re_detail
	{

struct range_pair
{
	ui_l32 first;
	ui_l32 second;

	void set(const ui_l32 min, const ui_l32 max)
	{
		this->first = min;
		this->second = max;
	}

	void set(const ui_l32 minmax)
	{
		this->first = minmax;
		this->second = minmax;
	}

	bool is_range_valid() const
	{
		return first <= second;
	}

	bool operator==(const range_pair &right) const
	{
		return this->first == right.first && this->second == right.second;
	}

	bool operator<(const range_pair &right) const
	{
		return this->second < right.first;
	}

	void swap(range_pair &right)
	{
		const range_pair tmp = *this;
		*this = right;
		right = tmp;
	}
};
//  range_pair

struct range_pair_helper : public range_pair
{
	range_pair_helper(const ui_l32 min, const ui_l32 max)
	{
		this->first = min;
		this->second = max;
	}

	range_pair_helper(const ui_l32 minmax)
	{
		this->first = minmax;
		this->second = minmax;
	}
};
//  range_pair_helper

struct range_pairs : public simple_array<range_pair>
{
public:

	typedef simple_array<range_pair> array_type;
	typedef array_type::size_type size_type;
	typedef array_type::sa_view view_type;

	range_pairs()
	{
	}

	range_pairs(const range_pairs &rp) : array_type(rp)
	{
	}

	range_pairs(const view_type &v) : array_type(v)
	{
	}

	range_pairs &operator=(const range_pairs &rp)
	{
		array_type::operator=(rp);
		return *this;
	}

#if defined(__cpp_rvalue_references)
	range_pairs(range_pairs &&rp) SRELL_NOEXCEPT
		: array_type(std::move(rp))
	{
	}

	range_pairs &operator=(range_pairs &&rp) SRELL_NOEXCEPT
	{
		array_type::operator=(std::move(rp));
		return *this;
	}
#endif

	void set_solerange(const range_pair &right)
	{
		this->resize(1);
		(*this)[0] = right;
	}

	void append_newclass(const range_pairs &right)
	{
		this->append(right);
	}

	void append_newpair(const range_pair &right)
	{
		this->push_back(right);
	}

	void append_newpairs(const range_pair *const p, const ui_l32 n)
	{
		this->append(p, n);
	}

	void join(const range_pair &right)
	{
		size_type count = this->size();

		if (count == 0)
		{
			this->push_back(right);
			return;
		}

		range_pair *base = &(*this)[0];

		do
		{
			size_type mid = count / 2;
			range_pair *cp = &base[mid];

			if (cp->first && (right.second < cp->first - 1))
			{
				count = mid;
			}
			else if (right.first && (cp->second < right.first - 1))
			{
				++mid;
				base += mid;
				count -= mid;
			}
			else
			{
				if (cp->first > right.first)
					cp->first = right.first;

				if (cp->second < right.second)
					cp->second = right.second;

				range_pair *lw = cp;

				if (cp->first > 0u)
				{
					for (--cp->first; lw != &(*this)[0];)
					{
						if ((--lw)->second < cp->first)
						{
							++lw;
							break;
						}
					}
					++cp->first;
				}
				else
					lw = &(*this)[0];

				if (lw != cp)
				{
					if (cp->first > lw->first)
						cp->first = lw->first;

					this->erase(lw - &(*this)[0], cp - lw);
					cp = lw;
				}

				range_pair *const rend = &(*this)[0] + this->size();
				range_pair *rw = cp;

				if (++cp->second > 0u)
				{
					for (; ++rw != rend;)
					{
						if (cp->second < rw->first)
							break;
					}
					--rw;
				}
				else
					rw = rend - 1;

				--cp->second;

				if (rw != cp)
				{
					if (rw->second < cp->second)
						rw->second = cp->second;

					rw->first = cp->first;
					this->erase(cp - &(*this)[0], rw - cp);
				}
				return;
			}
		}
		while (count);
		this->insert(base - &(*this)[0], right);
	}

	void merge(const range_pairs &right)
	{
		for (size_type i = 0; i < right.size(); ++i)
			join(right[i]);
	}

	void merge(const view_type &v)
	{
		for (size_type i = 0; i < v.size_; ++i)
			join(v.data_[i]);
	}

	bool same(ui_l32 pos, const ui_l32 count, const range_pairs &right) const
	{
		if (count != right.size())
			return false;

		for (ui_l32 i = 0; i < count; ++i, ++pos)
			if (!((*this)[pos] == right[i]))
				return false;

		return true;
	}

	int relationship(const range_pairs &right) const
	{
		if (this->size() == right.size())
		{
			for (size_type i = 0; i < this->size(); ++i)
			{
				if (!((*this)[i] == right[i]))
				{
					if (i == 0)
						goto check_overlap;

					return 1;	//  Overlapped.
				}
			}
			return 0;	//  Same.
		}
		check_overlap:
		return is_overlap(right) ? 1 : 2;	//  Overlapped or exclusive.
	}

	void negation()
	{
		ui_l32 begin = 0;
		size_type wpos = 0;

		for (size_type rpos = 0; rpos < this->size(); ++rpos)
		{
			const range_pair &rrange = (*this)[rpos];
			const ui_l32 nextbegin = rrange.second + 1;

			if (begin < rrange.first)
			{
				const ui_l32 prev2 = rrange.first - 1;
				range_pair &wrange = (*this)[wpos];

				wrange.second = prev2;
				wrange.first = begin;
				++wpos;
			}
			begin = nextbegin;
		}

		if (begin <= constants::unicode_max_codepoint)
		{
			if (wpos >= this->size())
				this->resize(wpos + 1);

			(*this)[wpos].set(begin, constants::unicode_max_codepoint);
		}
		else
			this->shrink(wpos);
	}

	bool is_overlap(const range_pairs &right) const
	{
		for (size_type i = 0; i < this->size(); ++i)
		{
			const range_pair &leftrange = (*this)[i];

			for (size_type j = 0; j < right.size(); ++j)
			{
				const range_pair &rightrange = right[j];

				if (rightrange.first <= leftrange.second)	//  Excludes l1 l2 < r1 r2.
					if (leftrange.first <= rightrange.second)	//  Excludes r1 r2 < l1 l2.
						return true;
			}
		}
		return false;
	}

	void load_from_memory(const ui_l32 *array, ui_l32 number_of_pairs)
	{
		for (; number_of_pairs; --number_of_pairs, array += 2)
			join(range_pair_helper(array[0], array[1]));
	}

	void make_caseunfoldedcharset()
	{
		ui_l32 table[ucf_constants::rev_maxset] = {};
		range_pairs newranges;

		for (size_type i = 0; i < this->size(); ++i)
		{
			const range_pair &range = (*this)[i];

			for (ui_l32 ucp = range.first; ucp <= range.second && ucp <= ucf_constants::rev_maxcp; ++ucp)
			{
				const ui_l32 setnum = unicode_case_folding::do_caseunfolding(table, ucp);

				for (ui_l32 j = 0; j < setnum; ++j)
				{
					if (table[j] != ucp)
						newranges.join(range_pair_helper(table[j]));
				}
			}
		}
		merge(newranges);
	}

	//  For updataout.hpp.
	void remove_range(const range_pair &right)
	{
		for (size_type pos = 0; pos < this->size();)
		{
			range_pair &left = (*this)[pos];

			if (right.first <= left.first)	//  r1 <= l1
			{
				if (left.first <= right.second)	//  r1 <= l1 <= r2.
				{
					if (right.second < left.second)	//  r1 <= l1 <= r2 < l2.
					{
						left.first = right.second + 1;
						return;
					}
					else	//  r1 <= l1 <= l2 <= r2.
						this->erase(pos);
				}
				else	//  r1 <= r2 < l1
					return;
			}
			//else	//  l1 < r1
			else if (right.first <= left.second)	//  l1 < r1 <= l2.
			{
				if (left.second <= right.second)	//  l1 < r1 <= l2 <= r2.
				{
					left.second = right.first - 1;
					++pos;
				}
				else	//  l1 < r1 <= r2 < l2
				{
					range_pair newrange(left);

					left.second = right.first - 1;
					newrange.first = right.second + 1;
					this->insert(++pos, newrange);
					return;
				}
			}
			else	//  l1 <= l2 < r1
				++pos;
		}
	}

	ui_l32 consists_of_one_character() const
	{
		if (this->size() == 1 && (*this)[0].first == (*this)[0].second)
			return (*this)[0].first;

		if (this->size())
		{
			ui_l32 found[ucf_constants::rev_maxset] = {};
			ui_l32 uf[ucf_constants::rev_maxset];
			const ui_l32 setnum = unicode_case_folding::do_caseunfolding(uf, (*this)[0].first);

			for (size_type i = 0; i < this->size(); ++i)
			{
				const range_pair &cr = (*this)[i];

				for (ui_l32 ucp = cr.first;; ++ucp)
				{
					for (ui_l32 j = 0;; ++j)
					{
						if (j == setnum)
							return constants::invalid_u32value;

						if (ucp == uf[j])
						{
							found[j] = 1;
							break;
						}
					}

					if (ucp == cr.second)
						break;
				}
			}
			for (ui_l32 i = 0; i < setnum; ++i)
			{
				if (found[i] == 0)
					return constants::invalid_u32value;
			}
			return uf[0] | masks::cfolded;
		}
		return constants::invalid_u32value;
	}

	void split_ranges(range_pairs &removed, const range_pairs &rightranges)
	{
		range_pairs &kept = *this;	//  Subtraction set.
		size_type prevolj = 0;
		range_pair newpair;

		removed.clear();	//  Intersection set.

		for (size_type i = 0;; ++i)
		{
			RETRY_SAMEINDEXNO:
			if (i >= kept.size())
				break;

			range_pair &left = kept[i];

			for (size_type j = prevolj; j < rightranges.size(); ++j)
			{
				const range_pair &right = rightranges[j];

				if (left.second < right.first)	//  Excludes l1 l2 < r1 r2.
					break;

				if (left.first <= right.second)	//  Excludes r1 r2 < l1 l2.
				{
					prevolj = j;

					if (left.first < right.first)	//  l1 < r1 <= r2.
					{
						if (right.second < left.second)	//  l1 < r1 <= r2 < l2.
						{
							removed.join(range_pair_helper(right.first, right.second));

							newpair.set(right.second + 1, left.second);
							left.second = right.first - 1;
							kept.insert(i + 1, newpair);
						}
						else	//  l1 < r1 <= l2 <= r2.
						{
							removed.join(range_pair_helper(right.first, left.second));
							left.second = right.first - 1;
						}
					}
					//else	//  r1 <= l1.
					else if (right.second < left.second)	//  r1 <= l1 <= r2 < l2.
					{
						removed.join(range_pair_helper(left.first, right.second));
						left.first = right.second + 1;
					}
					else	//  r1 <= l1 <= l2 <= r2.
					{
						removed.join(range_pair_helper(left.first, left.second));
						kept.erase(i);
						goto RETRY_SAMEINDEXNO;
					}
				}
			}
		}
	}

#if defined(SRELLDBG_NO_BITSET)
	bool is_included(const ui_l32 ch) const
	{
		const range_pair *const end = this->data() + this->size();

		for (const range_pair *cur = this->data(); cur != end; ++cur)
		{
			if (ch <= cur->second)
				return ch >= cur->first;
		}
		return false;
	}
#endif	//  defined(SRELLDBG_NO_BITSET)

	bool is_included(const ui_l32 pos, ui_l32 count, const ui_l32 c) const
	{
		const range_pair *base = &(*this)[pos];

		while (count)
		{
			ui_l32 mid = count >> 1;
			const range_pair &rp = base[mid];

			if (c <= rp.second)
			{
				if (c >= rp.first)
					return true;

				count = mid;
			}
			else
			{
				++mid;
				count -= mid;
				base += mid;
			}
		}
		return false;
	}

#if !defined(SRELLDBG_NO_CCPOS)

	//  For Eytzinger layout functions.

	bool is_included_el(ui_l32 pos, const ui_l32 len, const ui_l32 c) const
	{
		const range_pair *const base = &(*this)[pos];

#if defined(__GNUC__)
		__builtin_prefetch(base);
#endif
		for (pos = 0; pos < len;)
		{
			const range_pair &rp = base[pos];

			if (c < rp.first)
				pos = (pos << 1) + 1;
			else if (c > rp.second)
				pos = (pos << 1) + 2;
			else
				return true;
		}
		return false;
	}

	ui_l32 create_el(const range_pair *srcbase, const ui_l32 srcsize)
	{
		const ui_l32 basepos = static_cast<ui_l32>(this->size());

		this->resize(basepos + srcsize);
		set_eytzinger_layout(0, srcbase, srcsize, &(*this)[basepos], 0);

		return srcsize;
	}

#endif	//  !defined(SRELLDBG_NO_CCPOS)

	template <typename utf_traits>
	ui_l32 num_codeunits() const
	{
		ui_l32 prev2 = constants::invalid_u32value;
		ui_l32 num = 0;

		for (size_type no = 0; no < this->size(); ++no)
		{
			const range_pair &cr = (*this)[no];

			for (ui_l32 first = cr.first; first <= static_cast<ui_l32>(utf_traits::maxcpvalue);)
			{
				const ui_l32 nlc = utf_traits::nextlengthchange(first);
				const ui_l32 second = cr.second < nlc ? cr.second : (nlc - 1);
				const ui_l32 cu1 = utf_traits::firstcodeunit(first);
				const ui_l32 cu2 = utf_traits::firstcodeunit(second);

				num += cu2 - cu1 + (prev2 == cu1 ? 0 : 1);

				prev2 = cu2;
				if (second == cr.second)
					break;

				first = second + 1;
			}
		}
		return num;
	}

private:

	using array_type::push_back;
	using array_type::append;

#if !defined(SRELLDBG_NO_CCPOS)

	ui_l32 set_eytzinger_layout(ui_l32 srcpos, const range_pair *const srcbase, const ui_l32 srclen,
		range_pair *const destbase, const ui_l32 destpos)
	{
		if (destpos < srclen)
		{
			const ui_l32 nextpos = (destpos << 1) + 1;

			srcpos = set_eytzinger_layout(srcpos, srcbase, srclen, destbase, nextpos);
			destbase[destpos] = srcbase[srcpos++];
			srcpos = set_eytzinger_layout(srcpos, srcbase, srclen, destbase, nextpos + 1);
		}
		return srcpos;
	}

#endif	//  !defined(SRELLDBG_NO_CCPOS)

public:	//  For debug.

	void print_pairs(const int, const char *const = NULL, const char *const = NULL) const;
};
//  range_pairs

	}	//  namespace re_detail

//  ... "rei_range_pair.hpp"]
//  ["rei_char_class.hpp" ...

	namespace re_detail
	{

#if !defined(SRELL_NO_UNICODE_PROPERTY)

//  For RegExpIdentifierStart and RegExpIdentifierPart
struct identifier_charclass
{
public:

	void clear()
	{
		char_class_.clear();
		char_class_pos_.clear();
	}

	void setup()
	{
		if (char_class_pos_.size() == 0)
		{
			static const ui_l32 additions[] = {
				//  reg_exp_identifier_start, reg_exp_identifier_part.
				0x24, 0x24, 0x5f, 0x5f, 0x200c, 0x200d	//  '$' '_' <ZWNJ>-<ZWJ>
			};
			range_pairs ranges;

			//  For reg_exp_identifier_start.
			{
				const ui_l32 *const IDs_address = unicode_property::ranges_address(upid_bp_ID_Start);
				const ui_l32 IDs_number = unicode_property::number_of_ranges(upid_bp_ID_Start);
				ranges.load_from_memory(IDs_address, IDs_number);
			}
			ranges.load_from_memory(&additions[0], 2);
			append_charclass(ranges);

			//  For reg_exp_identifier_part.
			ranges.clear();
			{
				const ui_l32 *const IDc_address = unicode_property::ranges_address(upid_bp_ID_Continue);
				const ui_l32 IDc_number = unicode_property::number_of_ranges(upid_bp_ID_Continue);
				ranges.load_from_memory(IDc_address, IDc_number);
			}
			ranges.load_from_memory(&additions[0], 3);
			append_charclass(ranges);
		}
	}

	bool is_identifier(const ui_l32 ch, const bool part) const
	{
		const range_pair &rp = char_class_pos_[part ? 1 : 0];

		return char_class_.is_included(rp.first, rp.second, ch);
	}

private:

	void append_charclass(const range_pairs &rps)
	{
		char_class_pos_.push_back(range_pair_helper(static_cast<ui_l32>(char_class_.size()), static_cast<ui_l32>(rps.size())));
		char_class_.append_newclass(rps);
	}

	range_pairs char_class_;
	range_pairs::array_type char_class_pos_;

//  UnicodeIDStart::
//    any Unicode code point with the Unicode property "ID_Start"
//  UnicodeIDContinue::
//    any Unicode code point with the Unicode property "ID_Continue"
	static const ui_l32 upid_bp_ID_Start = static_cast<ui_l32>(up_constants::bp_ID_Start);
	static const ui_l32 upid_bp_ID_Continue = static_cast<ui_l32>(up_constants::bp_ID_Continue);
};
//  identifier_charclass
#endif	//  !defined(SRELL_NO_UNICODE_PROPERTY)

class re_character_class
{
public:

	enum
	{	//    0       1      2      3     4           5
		newline, dotall, space, digit, word, icase_word,
		//                6
		number_of_predefcls
	};

#if !defined(SRELL_NO_UNICODE_PROPERTY)
	typedef unicode_property::pstring pstring;
#endif

	re_character_class()
	{
		setup_predefinedclass();
	}

	re_character_class &operator=(const re_character_class &that)
	{
		if (this != &that)
		{
#if !defined(SRELLDBG_NO_CCPOS)
			this->char_class_el_ = that.char_class_el_;
			this->char_class_pos_el_ = that.char_class_pos_el_;
#endif
			this->char_class_ = that.char_class_;
			this->char_class_pos_ = that.char_class_pos_;
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	re_character_class &operator=(re_character_class &&that) SRELL_NOEXCEPT
	{
		if (this != &that)
		{
#if !defined(SRELLDBG_NO_CCPOS)
			this->char_class_el_ = std::move(that.char_class_el_);
			this->char_class_pos_el_ = std::move(that.char_class_pos_el_);
#endif
			this->char_class_ = std::move(that.char_class_);
			this->char_class_pos_ = std::move(that.char_class_pos_);
		}
		return *this;
	}
#endif

	bool is_included(const ui_l32 class_number, const ui_l32 c) const
	{
//		return char_class_.is_included(char_class_pos_[class_number], c);
		const range_pair &rp = char_class_pos_[class_number];

		return char_class_.is_included(rp.first, rp.second, c);
	}

#if !defined(SRELLDBG_NO_CCPOS)
	bool is_included(const ui_l32 pos, const ui_l32 len, const ui_l32 c) const
	{
		return char_class_el_.is_included_el(pos, len, c);
	}
#endif

	void reset()
	{
		char_class_.shrink(20);
		char_class_pos_.shrink(number_of_predefcls);

#if !defined(SRELLDBG_NO_CCPOS)
		char_class_el_.clear();
		char_class_pos_el_.clear();
#endif
	}

	ui_l32 register_newclass(const range_pairs &rps)
	{
		for (range_pairs::size_type no = 0; no < char_class_pos_.size(); ++no)
		{
			const range_pair &rp = char_class_pos_[no];

			if (char_class_.same(rp.first, rp.second, rps))
				return static_cast<ui_l32>(no);
		}

		append_charclass(rps);
		return static_cast<ui_l32>(char_class_pos_.size() - 1);
	}

	void copy_to(range_pairs &out, const ui_l32 no) const
	{
		const range_pair &ccpos = char_class_pos_[no];

		out.assign(&char_class_[ccpos.first], ccpos.second);
	}
	range_pairs::view_type view(const ui_l32 no) const
	{
		const range_pair &ccpos = char_class_pos_[no];

		return range_pairs::view_type(&char_class_[ccpos.first], ccpos.second);
	}

#if !defined(SRELLDBG_NO_CCPOS)

	const range_pair &charclasspos(const ui_l32 no)	//  const
	{
		range_pair &elpos = char_class_pos_el_[no];

		if (elpos.second == 0)
		{
			const range_pair &posinfo = char_class_pos_[no];

			if (posinfo.second > 0)
			{
				elpos.first = static_cast<ui_l32>(char_class_el_.size());
				elpos.second = char_class_el_.create_el(&char_class_[posinfo.first], posinfo.second);
			}
		}
		return elpos;
	}

	void finalise()
	{
		char_class_el_.clear();
		char_class_pos_el_.resize(char_class_pos_.size());
		std::memset(&char_class_pos_el_[0], 0, char_class_pos_el_.size() * sizeof (range_pairs::array_type::value_type));
	}

#endif	//  #if !defined(SRELLDBG_NO_CCPOS)

	void optimise()
	{
	}

#if !defined(SRELL_NO_UNICODE_PROPERTY)

	ui_l32 get_propertynumber(const u32view pname, const u32view pvalue) const
	{
		const ui_l32 pno = unicode_property::lookup_property(pname, pvalue);

		return (pno != up_constants::error_property) ? pno : up_constants::error_property;
	}

	bool load_upranges(range_pairs &newranges, const ui_l32 property_number) const
	{
		newranges.clear();

		if (unicode_property::is_valid_pno(property_number))
		{
			if (property_number == upid_bp_Assigned)
			{
				load_updata(newranges, upid_gc_Cn);
				newranges.negation();
			}
			else
				load_updata(newranges, property_number);

			return true;
		}
		return false;
	}

	//  Properties of strings.
	bool is_pos(const ui_l32 pno) const
	{
		return unicode_property::is_pos(pno);
	}

	bool get_prawdata(u32array &seq, ui_l32 property_number)
	{
		if (property_number != up_constants::error_property)
		{
			if (property_number == upid_bp_Assigned)
				property_number = upid_gc_Cn;

			const ui_l32 *const address = unicode_property::ranges_address(property_number);
//			const ui_l32 offset = unicode_property::ranges_offset(property_number);
			const ui_l32 number = unicode_property::number_of_ranges(property_number) * 2;

			seq.resize(number);
			for (ui_l32 i = 0; i < number; ++i)
				seq[i] = address[i];

			return true;
		}
		seq.clear();
		return false;
	}

#endif	//  !defined(SRELL_NO_UNICODE_PROPERTY)

	void swap(re_character_class &right)
	{
		if (this != &right)
		{
#if !defined(SRELLDBG_NO_CCPOS)
			this->char_class_el_.swap(right.char_class_el_);
			this->char_class_pos_el_.swap(right.char_class_pos_el_);
#endif
			this->char_class_.swap(right.char_class_);
			this->char_class_pos_.swap(right.char_class_pos_);
		}
	}

private:

#if !defined(SRELL_NO_UNICODE_PROPERTY)

	void load_updata(range_pairs &newranges, const ui_l32 property_number) const
	{
		const ui_l32 *const address = unicode_property::ranges_address(property_number);
//		const ui_l32 offset = unicode_property::ranges_offset(property_number);
		const ui_l32 number = unicode_property::number_of_ranges(property_number);

		newranges.load_from_memory(address, number);
	}

#endif	//  !defined(SRELL_NO_UNICODE_PROPERTY)

	void append_charclass(const range_pairs &rps)
	{
		char_class_pos_.push_back(range_pair_helper(static_cast<ui_l32>(char_class_.size()), static_cast<ui_l32>(rps.size())));
		char_class_.append_newclass(rps);
	}

//  The production CharacterClassEscape::s  evaluates as follows:
//    Return the set of characters containing the characters that are on the right-hand side of the WhiteSpace or LineTerminator productions.
//  WhiteSpace::<TAB> <VT> <FF> <SP> <NBSP> <ZWNBSP> <USP>
//               0009 000B 000C 0020   00A0     FEFF    Zs
//  LineTerminator::<LF> <CR> <LS> <PS>
//                  000A 000D 2028 2029
//
//  gc=Space_Separator:Zs
//  0x0020, 0x0020, 0x00A0, 0x00A0, 0x1680, 0x1680, 0x2000, 0x200A,
//  0x202F, 0x202F, 0x205F, 0x205F, 0x3000, 0x3000,

	void setup_predefinedclass()
	{
		static const range_pair allranges[] = {
			//  newline.
			{ 0x0a, 0x0a }, { 0x0d, 0x0d }, { 0x2028, 0x2029 },	//  \n \r
			//  dotall.
			{ 0x0000, 0x10ffff },
			//  space.
			{ 0x09, 0x0d },	//  \t \n \v \f \r
			{ 0x20, 0x20 },	//  ' '
			{ 0xa0, 0xa0 },	//  <NBSP>
			{ 0x1680, 0x1680 }, { 0x2000, 0x200a }, { 0x2028, 0x2029 },
			{ 0x202f, 0x202f }, { 0x205f, 0x205f }, { 0x3000, 0x3000 },
			{ 0xfeff, 0xfeff },	//  <BOM>
			//  digit, word. word-icase.
			{ 0x30, 0x39 },	//  '0'-'9'
			{ 0x41, 0x5a }, { 0x5f, 0x5f }, { 0x61, 0x7a },	//  'A'-'Z' '_' 'a'-'z'
			{ 0x017f, 0x017f }, { 0x212a, 0x212a }
		};
		static const range_pair offsets[] = {
			{ 0, 3 },	//  newline.
			{ 3, 1 },	//  dotall.
			{ 4, 10 },	//  space.
			{ 14, 1 },	//  digit.
			{ 14, 4 },	//  word.
			{ 14, 6 }	//  icase_word.
		};

		char_class_.append_newpairs(allranges, sizeof allranges / sizeof (range_pair));
		char_class_pos_.append(offsets, sizeof offsets / sizeof (range_pair));
	}

private:

#if !defined(SRELLDBG_NO_CCPOS)
	range_pairs char_class_el_;
	range_pairs::array_type char_class_pos_el_;
#endif

	range_pairs char_class_;
	range_pairs::array_type char_class_pos_;

#if !defined(SRELL_NO_UNICODE_PROPERTY)
	static const ui_l32 upid_gc_Zs = static_cast<ui_l32>(up_constants::gc_Space_Separator);
	static const ui_l32 upid_gc_Cn = static_cast<ui_l32>(up_constants::gc_Unassigned);
	static const ui_l32 upid_bp_Assigned = static_cast<ui_l32>(up_constants::bp_Assigned);
#endif

public:	//  For debug.

	void print_classes(const int) const;
};
//  re_character_class

	}	//  namespace re_detail

//  ... "rei_char_class.hpp"]
//  ["rei_groupname_mapper.hpp" ...

	namespace re_detail
	{

#if !defined(SRELL_NO_NAMEDCAPTURE)

template <typename charT>
class groupname_mapper
{
public:

	typedef simple_array<charT> gname_string;
	typedef typename gname_string::sa_view view_type;
	typedef std::size_t size_type;
	static const ui_l32 notfound = 0u;

	groupname_mapper()
	{
	}

	groupname_mapper(const groupname_mapper &right)
		: names_(right.names_), keysize_classno_(right.keysize_classno_)
	{
	}

#if defined(__cpp_rvalue_references)
	groupname_mapper(groupname_mapper &&right) SRELL_NOEXCEPT
		: names_(std::move(right.names_)), keysize_classno_(std::move(right.keysize_classno_))
	{
	}
#endif

	groupname_mapper &operator=(const groupname_mapper &right)
	{
		if (this != &right)
		{
			names_ = right.names_;
			keysize_classno_ = right.keysize_classno_;
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	groupname_mapper &operator=(groupname_mapper &&right) SRELL_NOEXCEPT
	{
		if (this != &right)
		{
			names_ = std::move(right.names_);
			keysize_classno_ = std::move(right.keysize_classno_);
		}
		return *this;
	}
#endif

	void clear()
	{
		names_.clear();
		keysize_classno_.clear();
	}

	const ui_l32 *operator[](const view_type &v) const
	{
		ui_l32 pos = 0;

		for (std::size_t i = 1; i < static_cast<std::size_t>(keysize_classno_.size());)
		{
			const ui_l32 keysize = keysize_classno_[i];
			const ui_l32 keynum = keysize_classno_[++i];

			if (keysize == v.size_ && sameseq_(pos, v))
				return &keysize_classno_[i];

			pos += keysize;
			i += keynum + 1;
		}
		return NULL;
	}

	view_type operator[](const ui_l32 indexno) const
	{
		ui_l32 pos = 0;

		for (std::size_t i = 1; i < static_cast<std::size_t>(keysize_classno_.size()); ++i)
		{
			const ui_l32 keysize = keysize_classno_[i];

			for (ui_l32 keynum = keysize_classno_[++i]; keynum; --keynum)
			{
				if (keysize_classno_[++i] == indexno)
					return view_type(&names_[pos], keysize);
			}
			pos += keysize;
		}
		return view_type();
	}

	size_type size() const
	{
		return keysize_classno_.size() ? keysize_classno_[0] : 0;
	}

	bool push_back(const gname_string &gname, const ui_l32 gno, const u32array &dupranges)
	{
		const ui_l32 *list = operator[](gname);

		if (list == NULL)
		{
			size_type curpos = keysize_classno_.size();

			names_.append(gname);
			keysize_classno_.resize(curpos ? (curpos + 3) : 4);
			if (curpos)
				++keysize_classno_[0];
			else
				keysize_classno_[curpos++] = 1;
			keysize_classno_[curpos++] = static_cast<ui_l32>(gname.size());
			keysize_classno_[curpos++] = 1;
			keysize_classno_[curpos] = gno;
			return true;
		}

		const size_type offset = list - keysize_classno_.data();
		const size_type keynum = list[0];

		for (size_type i = 1; i <= keynum; ++i)
		{
			const ui_l32 no = list[i];

			for (u32size_type j = 0;; ++j)
			{
				if (j >= dupranges.size())
					return false;

				if (no < dupranges[j])
				{
					if (j & 1)
						break;

					return false;
				}
			}
		}

		const size_type newkeynum = ++keysize_classno_[offset];

		keysize_classno_.insert(offset + newkeynum, gno);

		return true;
	}

	ui_l32 assign_number(const gname_string &gname, const ui_l32 gno)
	{
		const ui_l32 *list = operator[](gname);

		if (list == NULL)
		{
			size_type curpos = keysize_classno_.size();

			names_.append(gname);
			keysize_classno_.resize(curpos ? (curpos + 3) : 4);
			if (curpos)
				++keysize_classno_[0];
			else
				keysize_classno_[curpos++] = 1;
			keysize_classno_[curpos++] = static_cast<ui_l32>(gname.size());
			keysize_classno_[curpos++] = 1;
			keysize_classno_[curpos] = gno;
			return gno;
		}
		return list[1];
	}

	void swap(groupname_mapper &right)
	{
		this->names_.swap(right.names_);
		keysize_classno_.swap(right.keysize_classno_);
	}

private:

	bool sameseq_(size_type pos, const view_type &v) const
	{
		for (size_type i = 0; i < v.size_; ++i, ++pos)
			if (pos >= names_.size() || names_[pos] != v.data_[i])
				return false;

		return true;
	}

	gname_string names_;
	u32array keysize_classno_;

public:	//  For debug.

	void print_mappings(const int) const;
};
template <typename charT>
const ui_l32 groupname_mapper<charT>::notfound;
//  groupname_mapper

#endif	//  !defined(SRELL_NO_NAMEDCAPTURE)

	}	//  namespace re_detail

//  ... "rei_groupname_mapper.hpp"]
//  ["rei_state.hpp" ...

	namespace re_detail
	{

struct re_quantifier
{
	//  atleast and atmost: for check_counter and roundbracket_close.
	//  (Special case 1) in charcter_class, bol, eol, boundary, represents the offset and length
	//    of the range in the array of character classes.
	//  (Special case 1+) in NFA_states[0] holds a character class for one character lookahead.
	//  (Special case 2) in roundbracket_open and roundbracket_pop atleast and atmost represent
	//    the minimum and maximum bracket numbers respectively inside the brackets itself.
	//  (Special case 3) in repeat_in_push and repeat_in_pop atleast and atmost represent the
	//    minimum and maximum bracket numbers respectively inside the repetition.
	//  (Special case 4) in lookaround_open and lookaround_pop atleast and atmost represent the
	//    minimum and maximum bracket numbers respectively inside the lookaround.

	ui_l32 atleast;
	ui_l32 atmost;
	ui_l32 is_greedy;
		//  (Special case 1: v1) in lookaround_open represents the number of characters to be rewound.
		//  (Special case 2: v2) in lookaround_open represents: 0=lookaheads, 1=lookbehinds,
		//    2=matchpointrewinder, 3=rewinder+rerun.

	void reset(const ui_l32 len = 1)
	{
		atleast = atmost = len;
		is_greedy = 1;
	}

	void set(const ui_l32 min, const ui_l32 max)
	{
		atleast = min;
		atmost = max;
	}

	void set(const ui_l32 min, const ui_l32 max, const ui_l32 greedy)
	{
		atleast = min;
		atmost = max;
		is_greedy = greedy;
	}

	bool is_valid() const
	{
		return atleast <= atmost;
	}

	void set_infinity()
	{
		atmost = constants::infinity;
	}

	bool is_infinity() const
	{
		return atmost == constants::infinity;
	}

	bool is_same() const
	{
		return atleast == atmost;
	}

	bool is_default() const
	{
		return atleast == 1 && atmost == 1;
	}

	bool is_question() const
	{
		return atleast == 0 && atmost == 1;
	}
	bool is_asterisk() const
	{
		return atleast == 0 && atmost == constants::infinity;
	}
	bool is_plus() const
	{
		return atleast == 1 && atmost == constants::infinity;
	}
	bool is_asterisk_or_plus() const
	{
		return atleast <= 1 && atmost == constants::infinity;
	}

	bool has_simple_equivalence() const
	{
		return (atleast <= 1 && atmost <= 3) || (atleast == 2 && atmost <= 4) || (atleast == atmost && atmost <= 6);
	}

	void multiply(const re_quantifier &q)
	{
		const ui_l32 newal = atleast * q.atleast;

		atleast = (newal == 0 || (atleast != constants::infinity && q.atleast != constants::infinity && newal >= atleast)) ? newal : constants::infinity;

		const ui_l32 newam = atmost * q.atmost;

		atmost = (newam == 0 || (atmost != constants::infinity && q.atmost != constants::infinity && newam >= atmost)) ? newam : constants::infinity;
	}

	void add(const re_quantifier &q)
	{
		if (atleast != constants::infinity)
		{
			if (q.atleast != constants::infinity && (atleast + q.atleast) >= atleast)
				atleast += q.atleast;
			else
				atleast = constants::infinity;
		}

		if (atmost != constants::infinity)
		{
			if (q.atmost != constants::infinity && (atmost + q.atmost) >= atmost)
				atmost += q.atmost;
			else
				atmost = constants::infinity;
		}
	}
};
//  re_quantifier

struct re_state
{
	re_state_type type;

	ui_l32 char_num;
		//  character: for character.
		//  number: for character_class, brackets, counter, repeat, backreference.
		//  (Special case) in [0] represents a code unit for finding an entry point if
		//    the firstchar class consists of a single code unit; otherwise invalid_u32value.

	re_quantifier quantifier;	//  For check_counter, roundbrackets, repeasts, (?<=...) and (?<!...),
		//  and character_class.

	ui_l32 flags;
		//  Bit
		//    0: is_not; for \B, (?!...) and (?<!...).
		//       icase; for [0], backreference.
		//       multiline; for bol, eol.
		//       (Only bit used across compiler and algorithm).
		//    1: backrefno_unresolved. Used only in compiler.
		//    2: hooking. Used only in compiler.
		//    3: hookedlast. Used only in compiler.
		//    4: byn2. Used only in compiler.
		//    5: clrn2. Used only in compiler.

	union
	{
		std::ptrdiff_t next1;
		re_state *next_state1;
		//  (Special case 1) in lookaround_open points to the next of lookaround_close.
		//  (Special case 2) in lookaround_pop points to the content of brackets instead of lookaround_open.
	};
	union
	{
		std::ptrdiff_t next2;
		re_state *next_state2;
		//  character and character_class: points to another possibility, non-backtracking.
		//  epsilon: points to another possibility, backtracking.
		//  save_and_reset_counter, roundbracket_open, and repeat_in_push: points to a
		//    restore state, backtracking.
		//  check_counter: complementary to next1 based on quantifier.is_greedy.
		//  (Special case 1) roundbracket_close, check_0_width_repeat, and backreference:
		//    points to the next state as an exit after 0 width match.
		//  (Special case 2) in NFA_states[0] holds the entry point for match_continuous/regex_match.
		//  (Special case 3) in lookaround_open points to the contents of brackets.
	};

	void reset(const re_state_type t = st_character, const ui_l32 c = char_ctrl::cc_nul)
	{
		type = t;
		char_num = c;
		next1 = 1;
		next2 = 0;
		flags = 0u;
		quantifier.reset();
	}

	bool is_character_or_class() const
	{
		return type == st_character || type == st_character_class;
	}

	bool has_quantifier() const
	{
		//  1. character:  size == 1 && type == character,
		//  2. [...]:      size == 1 && type == character_class,
		//  3. (...):      size == ? && type == roundbracket_open,
		//  4. (?:...):    size == ? && type == epsilon && character == ':',
		//  5. backref:    size == ? && type == backreference,
		//  -- assertions boundary --
		//  6. lookaround: size == ? && type == lookaround_open,
		//  7. assertion:  size == 0 && type == one of assertions (^, $, \b and \B).
#if !defined(SRELL_ENABLE_GT)
		return type < st_zero_width_boundary;
#else
		//  5.5. independent: size == ? && type == lookaround && char_num == '>',
		return type < st_zero_width_boundary || (type == st_lookaround_open && char_num == meta_char::mc_gt);
#endif
	}

	bool is_ncgroup_open() const
	{
		return type == st_epsilon && char_num == epsilon_type::et_ncgopen;
	}

	bool is_ncgroup_open_or_close() const
	{
		return type == st_epsilon && next2 == 0 && (char_num == epsilon_type::et_ncgopen || char_num == epsilon_type::et_ncgclose);
	}

	bool is_alt() const
	{
		return type == st_epsilon && next2 != 0 && char_num == epsilon_type::et_alt;	//  '|'
	}

	bool is_question_or_asterisk_before_corcc() const
	{
		return type == st_epsilon && char_num == epsilon_type::et_ccastrsk;
	}

	bool is_asterisk_or_plus_for_onelen_atom() const
	{
		return type == st_epsilon && ((next1 == 1 && next2 == 2) || (next1 == 2 && next2 == 1)) && quantifier.is_asterisk_or_plus();
	}

	bool is_same_character_or_charclass(const re_state &right) const
	{
		return type == right.type && char_num == right.char_num
			&& (type != st_character || !((flags ^ right.flags) & regex_constants::icase));
	}

	std::ptrdiff_t nearnext() const
	{
		return quantifier.is_greedy ? next1 : next2;
	}

	std::ptrdiff_t farnext() const
	{
		return quantifier.is_greedy ? next2 : next1;
	}
};
//  re_state

template <typename charT>
struct re_compiler_state
{
	const ui_l32 *begin;
	ui_l32 soflags;
	ui_l32 depth;

	bool backref_used;

#if !defined(SRELL_NO_NAMEDCAPTURE)
	groupname_mapper<charT> unresolved_gnames;
	u32array dupranges;
#endif

#if !defined(SRELL_NO_UNICODE_PROPERTY)
	identifier_charclass idchecker;
#endif

	void reset(const regex_constants::syntax_option_type f, const ui_l32 *const b)
	{
		begin = b;
		soflags = f;
		depth = 0;
		backref_used = false;

#if !defined(SRELL_NO_NAMEDCAPTURE)
		unresolved_gnames.clear();
		dupranges.clear();
#endif

//		idchecker.clear();	//  Keeps data once created.
	}

	bool is_back() const
	{
		return (soflags & regex_constants::back_) ? true : false;
	}

	bool is_icase() const
	{
		return (soflags & regex_constants::icase) ? true : false;
	}

	bool is_multiline() const
	{
		return (soflags & regex_constants::multiline) ? true : false;
	}

	bool is_dotall() const
	{
		return (soflags & regex_constants::dotall) ? true : false;
	}

	bool is_vmode() const
	{
#if !defined(SRELL_NO_VMODE) && !defined(SRELL_NO_UNICODE_PROPERTY)
		return (soflags & regex_constants::unicodesets) ? true : false;
#else
		return false;
#endif
	}

	bool is_nosubs() const
	{
		return (soflags & regex_constants::nosubs) ? true : false;
	}
};
//  re_compiler_state

	}	//  namespace re_detail

//  ... "rei_state.hpp"]
//  ["rei_search_state.hpp" ...

	namespace re_detail
	{

template <typename BidirectionalIterator>
struct re_search_state_core
{
	const re_state *state;
	BidirectionalIterator iter;
};

template <typename BidirectionalIterator>
struct re_submatch_core
{
	BidirectionalIterator open_at;
	BidirectionalIterator close_at;
};

template <typename BidirectionalIterator>
struct re_submatch_type
{
	re_submatch_core<BidirectionalIterator> core;
	cntr_type counter;

	void init(const BidirectionalIterator b)
	{
		core.open_at = core.close_at = b;
		counter = 0;
	}
};

#if defined(SRELL_HAS_TYPE_TRAITS)
template <typename BidirectionalIterator, const bool>
#else
template <typename BidirectionalIterator>
#endif	//   defined(SRELL_HAS_TYPE_TRAITS)
struct re_search_state_types
{
	typedef re_submatch_core<BidirectionalIterator> submatch_core;
	typedef re_submatch_type<BidirectionalIterator> submatch_type;
	typedef cntr_type counter_type;
	typedef BidirectionalIterator position_type;

	typedef std::vector<submatch_type> submatch_array;

	typedef re_search_state_core<BidirectionalIterator> search_state_core;

	typedef std::vector<search_state_core> backtracking_array;
	typedef std::vector<submatch_core> capture_array;
	typedef simple_array<counter_type> counter_array;
	typedef std::vector<position_type> repeat_array;

	typedef typename backtracking_array::size_type btstack_size_type;

private:

	backtracking_array bt_stack;
	capture_array capture_stack;
	counter_array counter_stack;
	repeat_array repeat_stack;

public:

	void clear_stacks()
	{
		bt_stack.clear();
		capture_stack.clear();
		repeat_stack.clear();
		counter_stack.clear();
	}

	btstack_size_type bt_size() const
	{
		return bt_stack.size();
	}
	void bt_resize(const btstack_size_type s)
	{
		bt_stack.resize(s);
	}

	void expand(const btstack_size_type /* addlen */)
	{
	}
	void push_bt_wc(const search_state_core &ssc)
	{
		bt_stack.push_back(ssc);
	}

	void push_bt(const search_state_core &ssc)
	{
		bt_stack.push_back(ssc);
	}
	void push_sm(const submatch_core &smc)
	{
		capture_stack.push_back(smc);
	}
	void push_c(const counter_type c)
	{
		counter_stack.push_back(c);
	}
	void push_rp(const position_type p)
	{
		repeat_stack.push_back(p);
	}

	void pop_bt(search_state_core &ssc)
	{
		ssc = bt_stack.back();
		bt_stack.pop_back();
	}
	void pop_sm(submatch_core &smc)
	{
		smc = capture_stack.back();
		capture_stack.pop_back();
	}
	void pop_c(counter_type &c)
	{
		c = counter_stack.back();
		counter_stack.pop_back();
	}
	void pop_rp(position_type &p)
	{
		p = repeat_stack.back();
		repeat_stack.pop_back();
	}

public:

	struct bottom_state
	{
		btstack_size_type btstack_size;
		typename capture_array::size_type capturestack_size;
		typename counter_array::size_type counterstack_size;
		typename repeat_array::size_type repeatstack_size;

		bottom_state(const btstack_size_type bt, const re_search_state_types &ss)
			: btstack_size(bt)
			, capturestack_size(ss.capture_stack.size())
			, counterstack_size(ss.counter_stack.size())
			, repeatstack_size(ss.repeat_stack.size())
		{
		}
		void restore(btstack_size_type &bt, re_search_state_types &ss) const
		{
			bt = btstack_size;
			ss.capture_stack.resize(capturestack_size);
			ss.counter_stack.resize(counterstack_size);
			ss.repeat_stack.resize(repeatstack_size);
		}
	};
};

#if !defined(SRELL_NO_UNISTACK)
#if defined(SRELL_HAS_TYPE_TRAITS)
template <typename BidirectionalIterator>
struct re_search_state_types<BidirectionalIterator, true>
{
#else
template <typename charT>
struct re_search_state_types<const charT *>
{
	typedef const charT *BidirectionalIterator;
#endif
	typedef re_submatch_core<BidirectionalIterator> submatch_core;
	typedef re_submatch_type<BidirectionalIterator> submatch_type;
	typedef cntr_type counter_type;
	typedef BidirectionalIterator position_type;

	typedef simple_array<submatch_type> submatch_array;

	typedef re_search_state_core<BidirectionalIterator> search_state_core;

	typedef simple_stack backtracking_array;
	typedef simple_array<counter_type> counter_array;
	typedef simple_array<position_type> repeat_array;

	typedef typename backtracking_array::size_type btstack_size_type;

private:

	backtracking_array bt_stack;

public:

	void clear_stacks()
	{
		bt_stack.clear();
	}

	btstack_size_type bt_size() const
	{
		return bt_stack.size();
	}
	void bt_resize(const btstack_size_type s)
	{
		bt_stack.shrink(s);
	}

	void expand(const btstack_size_type addlen)
	{
		bt_stack.expand(addlen);
	}
	void push_bt_wc(const search_state_core &ssc)
	{
		bt_stack.push_back_t<search_state_core>(ssc);
	}

	void push_bt(const search_state_core &ssc)
	{
		bt_stack.push_back_t_nc<search_state_core>(ssc);
	}
	void push_sm(const submatch_core &smc)
	{
		bt_stack.push_back_t_nc<submatch_core>(smc);
	}
	void push_c(const counter_type c)
	{
		bt_stack.push_back_t_nc<counter_type>(c);
	}
	void push_rp(const position_type p)
	{
		bt_stack.push_back_t_nc<position_type>(p);
	}

	void pop_bt(search_state_core &ssc)
	{
		bt_stack.pop_back_t<search_state_core>(ssc);
	}
	void pop_sm(submatch_core &smc)
	{
		bt_stack.pop_back_t<submatch_core>(smc);
	}
	void pop_c(counter_type &c)
	{
		bt_stack.pop_back_t<counter_type>(c);
	}
	void pop_rp(position_type &p)
	{
		bt_stack.pop_back_t<position_type>(p);
	}

public:

	struct bottom_state
	{
		btstack_size_type btstack_size;

		bottom_state(const btstack_size_type bt, const re_search_state_types &)
			: btstack_size(bt)
		{
		}
		void restore(btstack_size_type &bt, re_search_state_types &) const
		{
			bt = btstack_size;
		}
	};
};
#endif	//  !defined(SRELL_NO_UNISTACK)
//  re_search_state_types

#if defined(SRELL_HAS_TYPE_TRAITS)

template <typename BidirectionalIterator>
class re_search_state : public re_search_state_types<BidirectionalIterator, std::is_trivially_copyable<BidirectionalIterator>::value>
{
private:
	typedef re_search_state_types<BidirectionalIterator, std::is_trivially_copyable<BidirectionalIterator>::value> base_type;

#else

template <typename BidirectionalIterator>
class re_search_state : public re_search_state_types<BidirectionalIterator>
{
private:
	typedef re_search_state_types<BidirectionalIterator> base_type;

#endif

public:

	typedef typename base_type::submatch_core submatchcore_type;
	typedef typename base_type::submatch_type submatch_type;
	typedef typename base_type::counter_type counter_type;
	typedef typename base_type::position_type position_type;

	typedef typename base_type::submatch_array submatch_array;

	typedef typename base_type::search_state_core search_state_core;

	typedef typename base_type::backtracking_array backtracking_array;
	typedef typename base_type::counter_array counter_array;
	typedef typename base_type::repeat_array repeat_array;

	typedef typename backtracking_array::size_type btstack_size_type;

	typedef typename base_type::bottom_state bottom_state;

public:

	btstack_size_type btstack_size;

	search_state_core ssc;

	submatch_array bracket;
	counter_array counter;
	repeat_array repeat;

#if !defined(SRELL_NO_LIMIT_COUNTER)
	std::size_t failure_counter;
#endif

	BidirectionalIterator reallblim;
	BidirectionalIterator srchbegin;
	BidirectionalIterator lblim;
	BidirectionalIterator curbegin;
	BidirectionalIterator nextpos;
	BidirectionalIterator srchend;

	const re_state *entry_state;
	regex_constants::match_flag_type flags;

public:

	void init(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		const BidirectionalIterator lookbehindlimit,
		const regex_constants::match_flag_type f)
	{
		reallblim = lblim = lookbehindlimit;
		nextpos = srchbegin = begin;
		srchend = end;
		flags = f;
	}

	void init2(const ui_l32 num_of_brackets, const ui_l32 num_of_counters, const ui_l32 num_of_repeats)
	{
		counter.resize(num_of_counters);
		repeat.resize(num_of_repeats);

		if (num_of_brackets > 1)	//  [0] is no longer used.
		{
			bracket.resize(num_of_brackets);

			for (ui_l32 i = 1; i < num_of_brackets; ++i)
				bracket[i].init(this->srchend);
		}

		btstack_size = 0;
		base_type::clear_stacks();
	}

#if defined(SRELL_NO_LIMIT_COUNTER)
	void reset()
#else
	void reset(const std::size_t limit)
#endif
	{
		ssc.state = this->entry_state;

		curbegin = ssc.iter;

#if !defined(SRELL_NO_LIMIT_COUNTER)
		failure_counter = limit;
#endif
	}

	bool set_bracket0(const BidirectionalIterator begin, const BidirectionalIterator end)
	{
		ssc.iter = begin;
		nextpos = end;
		return true;
	}
};
//  re_search_state

	}	//  namespace re_detail

//  ... "rei_search_state.hpp"]
//  ["rei_bmh.hpp" ...

	namespace re_detail
	{

#if !defined(SRELLDBG_NO_BMH)

template <typename charT, typename utf_traits>
class re_bmh
{
public:

	re_bmh()
	{
	}

	re_bmh(const re_bmh &right)
	{
		operator=(right);
	}

#if defined(__cpp_rvalue_references)
	re_bmh(re_bmh &&right) SRELL_NOEXCEPT
	{
		operator=(std::move(right));
	}
#endif

	re_bmh &operator=(const re_bmh &that)
	{
		if (this != &that)
		{
			this->u32string_ = that.u32string_;
			this->bmtable_ = that.bmtable_;
			this->repseq_ = that.repseq_;
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	re_bmh &operator=(re_bmh &&that) SRELL_NOEXCEPT
	{
		if (this != &that)
		{
			this->u32string_ = std::move(that.u32string_);
			this->bmtable_ = std::move(that.bmtable_);
			this->repseq_ = std::move(that.repseq_);
		}
		return *this;
	}
#endif

	void clear()
	{
		u32string_.clear();
		bmtable_.clear();
		repseq_.clear();
	}

	void setup(const u32array &u32s, const ui_l32 icase)
	{
		u32string_ = u32s;
		bmtable_.resize(257);
		repseq_.clear();

		if (icase == 0)
			setup_for_casesensitive_();
		else
			setup_for_icase_();
	}

	template <typename RandomAccessIterator>
	bool do_casesensitivesearch(re_search_state<RandomAccessIterator> &sstate, const std::random_access_iterator_tag) const
	{
		RandomAccessIterator begin = sstate.srchbegin;
		const RandomAccessIterator end = sstate.srchend;
		std::size_t offset = static_cast<std::size_t>(repseq_.size() - 1);
		const charT *const repseqend = repseq_.data() + repseq_.size();

		for (; static_cast<std::size_t>(end - begin) > offset;)
		{
			begin += offset;

			if (*begin == repseq_[0])
			{
				const charT *re = &repseq_[1];
				RandomAccessIterator tail = begin;

				for (; *re == *--tail;)
				{
					if (++re == repseqend)
						return sstate.set_bracket0(tail, ++begin);
				}
			}
			offset = bmtable_[*begin & 0xff];
		}
		return false;
	}

	template <typename BidirectionalIterator>
	bool do_casesensitivesearch(re_search_state<BidirectionalIterator> &sstate, const std::bidirectional_iterator_tag) const
	{
		BidirectionalIterator begin = sstate.srchbegin;
		const BidirectionalIterator end = sstate.srchend;
		std::size_t offset = static_cast<std::size_t>(repseq_.size() - 1);
		const charT *const repseqend = repseq_.data() + repseq_.size();

		for (;;)
		{
			for (; offset; --offset, ++begin)
				if (begin == end)
					return false;

			if (*begin == repseq_[0])
			{
				const charT *re = &repseq_[1];
				BidirectionalIterator tail = begin;

				for (; *re == *--tail;)
				{
					if (++re == repseqend)
						return sstate.set_bracket0(tail, ++begin);
				}
			}
			offset = bmtable_[*begin & 0xff];
		}
	}

	template <typename RandomAccessIterator>
	bool do_icasesearch(re_search_state<RandomAccessIterator> &sstate, const std::random_access_iterator_tag) const
	{
		const RandomAccessIterator begin = sstate.srchbegin;
		const RandomAccessIterator end = sstate.srchend;
		std::size_t offset = bmtable_[256];
		const ui_l32 entrychar = u32string_[0];
		const ui_l32 *const u32strend = u32string_.data() + u32string_.size();
		RandomAccessIterator curpos = begin;

		for (; static_cast<std::size_t>(end - curpos) > offset;)
		{
			curpos += offset;

			for (; utf_traits::is_trailing(*curpos);)
				if (++curpos == end)
					return false;

			RandomAccessIterator la(curpos);
			const ui_l32 txtlastchar = utf_traits::codepoint_inc(la, end);

			if (txtlastchar == entrychar || unicode_case_folding::do_casefolding(txtlastchar) == entrychar)
			{
				const ui_l32 *re = &u32string_[1];
				RandomAccessIterator tail = curpos;

				for (; *re == unicode_case_folding::do_casefolding(utf_traits::dec_codepoint(tail, begin));)
				{
					if (++re == u32strend)
						return sstate.set_bracket0(tail, la);

					if (tail == begin)
						break;
				}
			}
			offset = bmtable_[txtlastchar & 0xff];
		}
		return false;
	}

	template <typename BidirectionalIterator>
	bool do_icasesearch(re_search_state<BidirectionalIterator> &sstate, const std::bidirectional_iterator_tag) const
	{
		const BidirectionalIterator begin = sstate.srchbegin;
		const BidirectionalIterator end = sstate.srchend;

		if (begin != end)
		{
			std::size_t offset = bmtable_[256];
			const ui_l32 entrychar = u32string_[0];
			const ui_l32 *const u32strend = u32string_.data() + u32string_.size();
			BidirectionalIterator curpos = begin;

			for (;;)
			{
				do
				{
					if (++curpos == end)
						return false;
				}
				while (--offset);

				for (; utf_traits::is_trailing(*curpos);)
					if (++curpos == end)
						return false;

				BidirectionalIterator la(curpos);
				const ui_l32 txtlastchar = utf_traits::codepoint_inc(la, end);

				if (txtlastchar == entrychar || unicode_case_folding::do_casefolding(txtlastchar) == entrychar)
				{
					const ui_l32 *re = &u32string_[1];
					BidirectionalIterator tail = curpos;

					for (; *re == unicode_case_folding::do_casefolding(utf_traits::dec_codepoint(tail, begin));)
					{
						if (++re == u32strend)
							return sstate.set_bracket0(tail, la);

						if (tail == begin)
							break;
					}
				}
				offset = bmtable_[txtlastchar & 0xff];
			}
		}
		return false;
	}

private:

	void setup_for_casesensitive_()
	{
		charT mbstr[utf_traits::maxseqlen];

		for (std::size_t i = 0; i < static_cast<std::size_t>(u32string_.size()); ++i)
		{
			const ui_l32 seqlen = utf_traits::to_codeunits(mbstr, u32string_[i]);

			repseq_.append(mbstr, seqlen);
		}

		repseq_.reverse();

		for (ui_l32 i = 0; i < 256; ++i)
			bmtable_[i] = static_cast<std::size_t>(repseq_.size());

		for (std::size_t i = static_cast<std::size_t>(repseq_.size() - 1); i; --i)
			bmtable_[repseq_[i] & 0xff] = i;
	}

	void setup_for_icase_()
	{
		ui_l32 unfolded[ucf_constants::rev_maxset];
		std::size_t culensum = 0;

		std::memset(&bmtable_[0], 0, sizeof (std::size_t) * bmtable_.size());
		u32string_.reverse();

		for (std::size_t i = 1; i < static_cast<std::size_t>(u32string_.size()); ++i)
		{
			const ui_l32 setnum = unicode_case_folding::do_caseunfolding(unfolded, u32string_[i]);
			ui_l32 u32c = unfolded[0];

			for (ui_l32 j = 1; j < setnum; ++j)
				if (u32c > unfolded[j])
					u32c = unfolded[j];

			culensum += utf_traits::seqlen(u32c);

			for (ui_l32 j = 0; j < setnum; ++j)
			{
				std::size_t &val = bmtable_[unfolded[j] & 0xff];
				if (val == 0)
					val = culensum;
			}
		}

		bmtable_[256] = culensum;

		++culensum;

		for (ui_l32 i = 0; i < 256; ++i)
			if (bmtable_[i] == 0)
				bmtable_[i] = culensum;
	}

public:	//  For debug.

	void print_table() const;
	void print_seq() const;

private:

	u32array u32string_;
	simple_array<std::size_t> bmtable_;
	simple_array<charT> repseq_;
};
//  re_bmh

#endif	//  !defined(SRELLDBG_NO_BMH)
	}	//  namespace re_detail

//  ... "rei_bmh.hpp"]
//  ["rei_upos.hpp" ...

	namespace re_detail
	{

struct posdata_holder
{
	u32array indices;
	u32array seqs;
	range_pairs ranges;
	range_pair length;

	void clear()
	{
		indices.clear();
		seqs.clear();
		ranges.clear();
		length.set(1);
	}

	bool has_empty() const
	{
		return (indices.size() >= 2 && indices[0] != indices[1]) ? true : false;
	}

	bool has_data() const
	{
		return ranges.size() > 0 || indices.size() > 0;
	}

	bool may_contain_strings() const
	{
		return indices.size() > 0;	//  >= 2;
	}

	void swap(posdata_holder &right)
	{
		indices.swap(right.indices);
		seqs.swap(right.seqs);
		ranges.swap(right.ranges);
		length.swap(right.length);
	}

	void do_union(const posdata_holder &right)
	{
		u32array curseq;

		ranges.merge(right.ranges);

		if (right.has_empty() && !has_empty())
			register_emptystring();

		for (ui_l32 seqlen = 2; seqlen < static_cast<ui_l32>(right.indices.size()); ++seqlen)
		{
			const ui_l32 end = right.indices[seqlen - 1];
			ui_l32 begin = right.indices[seqlen];

			if (begin != end)
			{
				ensure_length(seqlen);
				curseq.resize(seqlen);

				for (; begin < end;)
				{
					const ui_l32 inspos = find_seq(&right.seqs[begin], seqlen);

					if (inspos == indices[seqlen - 1])
					{
						for (ui_l32 i = 0; i < seqlen; ++i, ++begin)
							curseq[i] = right.seqs[begin];

						seqs.insert(inspos, curseq);
						for (ui_l32 i = 0; i < seqlen; ++i)
							indices[i] += seqlen;
					}
					else
						begin += seqlen;
				}
			}
		}
		check_lengths();
	}

	void do_subtract(const posdata_holder &right)
	{
		const ui_l32 maxlen = static_cast<ui_l32>(indices.size() <= right.indices.size() ? indices.size() : right.indices.size());

		{
			range_pairs removed;

			ranges.split_ranges(removed, right.ranges);
		}

		if (right.has_empty() && has_empty())
			unregister_emptystring();

		for (ui_l32 seqlen = 2; seqlen < maxlen; ++seqlen)
		{
			const ui_l32 end = right.indices[seqlen - 1];
			ui_l32 begin = right.indices[seqlen];

			if (begin != end)
			{
				for (; begin < end;)
				{
					const ui_l32 delpos = find_seq(&right.seqs[begin], seqlen);

					if (delpos < indices[seqlen - 1])
					{
						seqs.erase(delpos, seqlen);

						for (ui_l32 i = 0; i < seqlen; ++i)
							indices[i] -= seqlen;
					}
					else
						begin += seqlen;
				}
			}
		}
		check_lengths();
	}

	void do_and(const posdata_holder &right)
	{
		const ui_l32 maxlen = static_cast<ui_l32>(indices.size() <= right.indices.size() ? indices.size() : right.indices.size());
		posdata_holder newpos;
		u32array curseq;

		ranges.split_ranges(newpos.ranges, right.ranges);
		ranges.swap(newpos.ranges);

		if (has_empty() && right.has_empty())
			newpos.register_emptystring();
		else if (may_contain_strings() || right.may_contain_strings())
			ensure_length(1);

		for (ui_l32 seqlen = 2; seqlen < maxlen; ++seqlen)
		{
			const ui_l32 end = right.indices[seqlen - 1];
			ui_l32 begin = right.indices[seqlen];

			if (begin != end)
			{
				const ui_l32 myend = indices[seqlen - 1];

				curseq.resize(seqlen);

				for (; begin < end; begin += seqlen)
				{
					const ui_l32 srcpos = find_seq(&right.seqs[begin], seqlen);

					if (srcpos < myend)
					{
						newpos.ensure_length(seqlen);

						const ui_l32 inspos = newpos.find_seq(&right.seqs[begin], seqlen);

						if (inspos == newpos.indices[seqlen - 1])
						{
							for (ui_l32 i = 0; i < seqlen; ++i)
								curseq[i] = right.seqs[begin + i];

							newpos.seqs.insert(inspos, curseq);
							for (ui_l32 i = 0; i < seqlen; ++i)
								newpos.indices[i] += seqlen;
						}
					}
				}
			}
		}
		this->indices.swap(newpos.indices);
		this->seqs.swap(newpos.seqs);
		check_lengths();
	}

	void split_seqs_and_ranges(const u32array &inseqs, const bool icase, const bool back)
	{
		const ui_l32 max = static_cast<ui_l32>(inseqs.size());
		u32array curseq;

		clear();

		for (ui_l32 indx = 0; indx < max;)
		{
			const ui_l32 elen = inseqs[indx++];

			if (elen == 1)	//  Range.
			{
				ranges.join(range_pair_helper(inseqs[indx], inseqs[indx + 1]));
				indx += 2;
			}
			else if (elen == 2)
			{
				const ui_l32 ucpval = inseqs[indx++];

				if (ucpval != constants::ccstr_empty)
					ranges.join(range_pair_helper(ucpval));
				else
					register_emptystring();
			}
			else if (elen >= 3)
			{
				const ui_l32 seqlen = elen - 1;

				ensure_length(seqlen);

				const ui_l32 inspos = indices[seqlen - 1];

				curseq.resize(seqlen);
				if (!back)
				{
					for (ui_l32 j = 0; j < seqlen; ++j, ++indx)
						curseq[j] = inseqs[indx];
				}
				else
				{
					for (ui_l32 j = seqlen; j; ++indx)
						curseq[--j] = inseqs[indx];
				}

				if (icase)
				{
					for (u32size_type i = 0; i < curseq.size(); ++i)
					{
						const ui_l32 cf = unicode_case_folding::try_casefolding(curseq[i]);

						if (cf != constants::invalid_u32value)
							curseq[i] = cf | masks::cfolded;
					}
				}

				for (ui_l32 i = indices[seqlen];; i += seqlen)
				{
					if (i == inspos)
					{
						seqs.insert(inspos, curseq);
						for (ui_l32 j = 0; j < seqlen; ++j)
							indices[j] += seqlen;
						break;
					}

					if (is_sameseq(&seqs[i], curseq.data(), seqlen))
						break;
				}

			}
			//elen == 0: Padding.
		}

		if (icase)
			ranges.make_caseunfoldedcharset();

		check_lengths();
	}

private:

	void register_emptystring()
	{
		if (indices.size() < 2)
		{
			indices.resize(2);
			indices[1] = 0;
			indices[0] = 1;
		}
		else if (indices[0] == indices[1])
		{
			++indices[0];
		}
		length.first = 0;
	}

	void unregister_emptystring()
	{
		if (indices.size() >= 2 && indices[0] != indices[1])
			indices[0] = indices[1];
	}

	void ensure_length(const ui_l32 seqlen)
	{
		ui_l32 curlen = static_cast<ui_l32>(indices.size());

		if (seqlen >= curlen)
		{
			indices.resize(seqlen + 1);
			for (; curlen <= seqlen; ++curlen)
				indices[curlen] = 0;
		}
	}

	ui_l32 find_seq(const ui_l32 *const seqbegin, const ui_l32 seqlen) const
	{
		const ui_l32 end = indices[seqlen - 1];

		for (ui_l32 begin = indices[seqlen]; begin < end; begin += seqlen)
		{
			if (is_sameseq(seqbegin, &seqs[begin], seqlen))
				return begin;
		}
		return end;
	}

	void check_lengths()
	{
		length.set(constants::max_u32value, 0);

		for (ui_l32 i = 2; i < static_cast<ui_l32>(indices.size()); ++i)
		{
			if (indices[i] != indices[i - 1])
			{
				if (length.first > i)
					length.first = i;
				if (length.second < i)
					length.second = i;
			}
		}

		if (ranges.size())
		{
			if (length.first > 1)
				length.first = 1;
			if (length.second < 1)
				length.second = 1;
		}

		if (has_empty())
			length.first = 0;

		if (length.second == 0)
			length.first = 0;
	}

	bool is_sameseq(const ui_l32 *const s1, const ui_l32 *const s2, const ui_l32 len) const
	{
		for (ui_l32 i = 0; i < len; ++i)
			if (s1[i] != s2[i])
				return false;
		return true;
	}
};
//  posdata_holder

	}	//  namespace re_detail

//  ... "rei_upos.hpp"]
//  ["rei_compiler.hpp" ...

	namespace re_detail
	{

#if defined(SRELLDBG_NO_1STCHRCLS)
#define SRELLDBG_NO_BITSET
#define SRELLDBG_NO_SCFINDER
#undef SRELL_HAS_SSE42
#endif

#if defined(SRELLDBG_NO_ASTERISK_OPT)
#define SRELLDBG_NO_BRANCH_OPT
#define SRELLDBG_NO_POS_OPT
#endif

#if defined(SRELLDBG_NO_STATEHOOK)
#define SRELLDBG_NO_BRANCH_OPT2
#define SRELLDBG_NO_POS_OPT
#endif

#if defined(SRELL_FIXEDWIDTHLOOKBEHIND)
#define SRELLDBG_NO_MPREWINDER
#endif

#if !defined(SRELL_MAX_DEPTH) || ((SRELL_MAX_DEPTH + 0) == 0)
#undef SRELL_MAX_DEPTH
#define SRELL_MAX_DEPTH 256
#endif

template <typename charT, typename traits>
struct re_object_core
{
protected:

	typedef re_state state_type;
	typedef simple_array<state_type> state_array;

	state_array NFA_states;
	re_character_class character_class;

#if !defined(SRELLDBG_NO_1STCHRCLS)
	#if !defined(SRELLDBG_NO_BITSET)
	bitset<traits::utf_traits::bitsetsize> firstchar_class_bs;
	#endif
#endif

#if !defined(SRELL_NO_LIMIT_COUNTER)
public:

	std::size_t limit_counter;

protected:
#endif

	typedef typename traits::utf_traits utf_traits;

	ui_l32 number_of_brackets;
	ui_l32 number_of_counters;
	ui_l32 number_of_repeats;
	ui_l32 soflags;

#if !defined(SRELL_NO_NAMEDCAPTURE)
	groupname_mapper<charT> namedcaptures;
	typedef typename groupname_mapper<charT>::gname_string gname_string;
#endif

#if !defined(SRELLDBG_NO_BMH)
	typedef re_bmh<charT, utf_traits> bmh_type;
	bmh_type *bmdata;
#endif

#if defined(SRELL_HAS_SSE42)
	__m128i simdranges;
#endif

#if !defined(SRELL_NO_LIMIT_COUNTER)
private:

	SRELL_STACON std::size_t lcounter_defnum_ = 1 << 21;

#endif

protected:

	re_object_core()
#if !defined(SRELL_NO_LIMIT_COUNTER)
		: limit_counter(lcounter_defnum_)
#if !defined(SRELLDBG_NO_BMH)
		, bmdata(NULL)
#endif
#elif !defined(SRELLDBG_NO_BMH)
		: bmdata(NULL)
#endif
	{
	}

	re_object_core(const re_object_core &right)
#if !defined(SRELLDBG_NO_BMH)
		: bmdata(NULL)
#endif
	{
		operator=(right);
	}

#if defined(__cpp_rvalue_references)
	re_object_core(re_object_core &&right) SRELL_NOEXCEPT
#if !defined(SRELLDBG_NO_BMH)
		: bmdata(NULL)
#endif
	{
		operator=(std::move(right));
	}
#endif

#if !defined(SRELLDBG_NO_BMH)
	~re_object_core()
	{
		if (bmdata)
			delete bmdata;
	}
#endif

	void reset(const regex_constants::syntax_option_type flags)
	{
		NFA_states.clear();
		character_class.reset();

#if !defined(SRELLDBG_NO_1STCHRCLS)
	#if !defined(SRELLDBG_NO_BITSET)
		firstchar_class_bs.reset();
	#endif
#endif

#if !defined(SRELL_NO_LIMIT_COUNTER)
		limit_counter = lcounter_defnum_;
#endif

		number_of_brackets = 1;
		number_of_counters = 0;
		number_of_repeats  = 0;
		soflags = static_cast<ui_l32>(flags);	//  regex_constants::ECMAScript;

#if !defined(SRELL_NO_NAMEDCAPTURE)
		namedcaptures.clear();
#endif

#if !defined(SRELLDBG_NO_BMH)
		if (bmdata)
			delete bmdata;
		bmdata = NULL;
#endif
	}

	re_object_core &operator=(const re_object_core &that)
	{
		if (this != &that)
		{
			this->NFA_states = that.NFA_states;
			this->character_class = that.character_class;

#if !defined(SRELLDBG_NO_1STCHRCLS)
	#if !defined(SRELLDBG_NO_BITSET)
			this->firstchar_class_bs = that.firstchar_class_bs;
	#endif
#endif

#if !defined(SRELL_NO_LIMIT_COUNTER)
			this->limit_counter = that.limit_counter;
#endif

			this->number_of_brackets = that.number_of_brackets;
			this->number_of_counters = that.number_of_counters;
			this->number_of_repeats = that.number_of_repeats;
			this->soflags = that.soflags;

#if !defined(SRELL_NO_NAMEDCAPTURE)
			this->namedcaptures = that.namedcaptures;
#endif

#if !defined(SRELLDBG_NO_BMH)
			if (that.bmdata)
			{
				if (this->bmdata)
					*this->bmdata = *that.bmdata;
				else
					this->bmdata = new bmh_type(*that.bmdata);
			}
			else if (this->bmdata)
			{
				delete this->bmdata;
				this->bmdata = NULL;
			}
#endif
#if defined(SRELL_HAS_SSE42)
			simdranges = that.simdranges;
#endif

			if (that.NFA_states.size())
				repair_nextstates(&that.NFA_states[0]);
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	re_object_core &operator=(re_object_core &&that) SRELL_NOEXCEPT
	{
		if (this != &that)
		{
			this->NFA_states = std::move(that.NFA_states);
			this->character_class = std::move(that.character_class);

#if !defined(SRELLDBG_NO_1STCHRCLS)
	#if !defined(SRELLDBG_NO_BITSET)
			this->firstchar_class_bs = std::move(that.firstchar_class_bs);
	#endif
#endif

#if !defined(SRELL_NO_LIMIT_COUNTER)
			this->limit_counter = that.limit_counter;
#endif

			this->number_of_brackets = that.number_of_brackets;
			this->number_of_counters = that.number_of_counters;
			this->number_of_repeats = that.number_of_repeats;
			this->soflags = that.soflags;

#if !defined(SRELL_NO_NAMEDCAPTURE)
			this->namedcaptures = std::move(that.namedcaptures);
#endif

#if !defined(SRELLDBG_NO_BMH)
			if (this->bmdata)
				delete this->bmdata;
			this->bmdata = that.bmdata;
			that.bmdata = NULL;
#endif
#if defined(SRELL_HAS_SSE42)
			simdranges = that.simdranges;
#endif
		}
		return *this;
	}
#endif	//  defined(__cpp_rvalue_references)

	void swap(re_object_core &right)
	{
		if (this != &right)
		{
			this->NFA_states.swap(right.NFA_states);
			this->character_class.swap(right.character_class);

#if !defined(SRELLDBG_NO_1STCHRCLS)
	#if !defined(SRELLDBG_NO_BITSET)
			this->firstchar_class_bs.swap(right.firstchar_class_bs);
	#endif
#endif

#if !defined(SRELL_NO_LIMIT_COUNTER)
			{
				const std::size_t tmp_limit_counter = this->limit_counter;
				this->limit_counter = right.limit_counter;
				right.limit_counter = tmp_limit_counter;
			}
#endif

			{
				const ui_l32 tmp_numof_brackets = this->number_of_brackets;
				this->number_of_brackets = right.number_of_brackets;
				right.number_of_brackets = tmp_numof_brackets;
			}
			{
				const ui_l32 tmp_numof_counters = this->number_of_counters;
				this->number_of_counters = right.number_of_counters;
				right.number_of_counters = tmp_numof_counters;
			}
			{
				const ui_l32 tmp_numof_repeats = this->number_of_repeats;
				this->number_of_repeats = right.number_of_repeats;
				right.number_of_repeats = tmp_numof_repeats;
			}
			{
				const ui_l32 tmp_soflags = this->soflags;
				this->soflags = right.soflags;
				right.soflags = tmp_soflags;
			}

#if !defined(SRELL_NO_NAMEDCAPTURE)
			this->namedcaptures.swap(right.namedcaptures);
#endif

#if !defined(SRELLDBG_NO_BMH)
			{
				bmh_type *const tmp_bmdata = this->bmdata;
				this->bmdata = right.bmdata;
				right.bmdata = tmp_bmdata;
			}
#endif
#if defined(SRELL_HAS_SSE42)
			{
				const __m128i tmp = this->simdranges;
				this->simdranges = right.simdranges;
				right.simdranges = tmp;
			}
#endif
		}
	}

	bool set_error(const regex_constants::error_type e)
	{
//		reset();
		NFA_states.clear();
		soflags |= static_cast<ui_l32>(e) << constants::errshift;
		return false;
	}

	regex_constants::error_type ecode() const
	{
		return static_cast<regex_constants::error_type>(soflags >> constants::errshift);
	}

private:

	void repair_nextstates(const state_type *const oldbase)
	{
		state_type *const newbase = &this->NFA_states[0];

		for (typename state_array::size_type i = 0; i < this->NFA_states.size(); ++i)
		{
			state_type &state = this->NFA_states[i];

			if (state.next_state1)
				state.next_state1 = state.next_state1 - oldbase + newbase;

			if (state.next_state2)
				state.next_state2 = state.next_state2 - oldbase + newbase;
		}
	}
};
//  re_object_core

#if defined(SRELL_HAS_SSE42)

template <typename T>
struct cpu_checker
{
	static T x86simd()
	{
		static const T v = check_();

		return v;
	}

private:

	static T check_()
	{
#if defined(__GNUC__)
		return (__builtin_cpu_supports("sse4.2") ? 1 : 0)
			| (__builtin_cpu_supports("avx2") ? 2 : 0);	//  Only for VPCMPEQB.
#elif defined(_MSC_VER)
		int cpuInfo[4];
		T v = 0;

		__cpuid(cpuInfo, 0);
		const int max = cpuInfo[0];

		if (max >= 1)
		{
			__cpuid(cpuInfo, 1);
			v |= (cpuInfo[2] & (1 << 20)) ? 1 : 0;	//  ecx. SSE4.2.
			if (max >= 7)
			{
				__cpuidex(cpuInfo, 7, 0);
				v |= (cpuInfo[1] & (1 << 5)) ? 2 : 0;	//  ebx. AVX2.
			}
		}
		return v;
#else
		return 0;
#endif
	}
};
//  cpu_checker

#endif	//  defined(SRELL_HAS_SSE42)

template <typename charT, typename traits>
class re_compiler : public re_object_core<charT, traits>
{
protected:

	template <typename InputIterator>
	bool compile(InputIterator begin, const InputIterator end, const regex_constants::syntax_option_type flags)
	{
		u32array u32;

		this->reset(flags);

		if (!to_u32array(u32, begin, end) || !compile_core(u32.data(), u32.data() + u32.size(), flags & regex_constants::pflagsmask_))
		{
#if !defined(SRELLDBG_NO_BMH)
			if (this->bmdata)
				delete this->bmdata;
			this->bmdata = NULL;
#endif
#if !defined(SRELL_NO_THROW)
			if (!(this->soflags & regex_constants::quiet))
				throw regex_error(this->ecode());
#else
			return false;
#endif
		}
		return true;
	}

private:

	typedef re_object_core<charT, traits> base_type;
	typedef typename base_type::utf_traits utf_traits;
	typedef typename base_type::state_type state_type;
	typedef typename base_type::state_array state_array;
#if !defined(SRELL_NO_NAMEDCAPTURE)
	typedef typename base_type::gname_string gname_string;
#endif
#if !defined(SRELL_NO_UNICODE_PROPERTY)
	typedef typename re_character_class::pstring pstring;
#endif
#if !defined(SRELLDBG_NO_BMH)
	typedef typename base_type::bmh_type bmh_type;
#endif
	typedef typename state_array::size_type state_size_type;

	typedef re_compiler_state<charT> cvars_type;

	template <typename InputIterator>
	bool to_u32array(u32array &u32, InputIterator begin, const InputIterator end)
	{
		while (begin != end)
		{
			const ui_l32 u32c = utf_traits::codepoint_inc(begin, end);

			if (u32c > constants::unicode_max_codepoint)
				return this->set_error(regex_constants::error_utf8);

			u32.push_back_c(u32c);
		}
		return true;
	}

	bool compile_core(const ui_l32 *begin, const ui_l32 *const end, const regex_constants::syntax_option_type flags)
	{
		re_quantifier piecesize;
		cvars_type cvars;
		state_type flstate;

		cvars.reset(flags, begin);

		flstate.reset(st_epsilon);
		flstate.next2 = 1;
		this->NFA_states.push_back(flstate);

		if (!make_nfa_states(this->NFA_states, piecesize, begin, end, cvars))
		{
			return false;
		}

		if (begin != end)
			return this->set_error(regex_constants::error_paren);	//  ')'s are too many.

#if !defined(SRELLDBG_NO_BMH)
		setup_bmhdata();
#endif

		flstate.type = st_success;
		flstate.next1 = 0;
		flstate.next2 = 0;
		flstate.quantifier = piecesize;
		this->NFA_states.push_back(flstate);

		if (cvars.backref_used && !check_backreferences(cvars))
			return false;

		const bool has_fcc = optimise(cvars);
		finalise(has_fcc);

		return true;
	}

	bool make_nfa_states(state_array &piece, re_quantifier &piecesize, const ui_l32 *&curpos, const ui_l32 *const end, cvars_type &cvars)
	{
#if !defined(SRELL_NO_NAMEDCAPTURE)
		const ui_l32 gno_at_groupbegin = this->number_of_brackets;
		bool already_pushed = false;
#endif
		state_size_type prevbranch_end = 0;
		state_type bstate;
		state_array branch;
		re_quantifier branchsize;

		piecesize.set(constants::infinity, 0, 0);

		bstate.reset(st_epsilon, epsilon_type::et_alt);

		for (;;)
		{
			branch.clear();

			if (!make_branch(branch, branchsize, curpos, end, cvars))
				return false;

			if (!piecesize.is_valid() || piecesize.atleast > branchsize.atleast)
				piecesize.atleast = branchsize.atleast;

			if (piecesize.atmost < branchsize.atmost)
				piecesize.atmost = branchsize.atmost;

			if (curpos != end && *curpos == meta_char::mc_bar)
			{
				bstate.next2 = static_cast<std::ptrdiff_t>(branch.size()) + 2;
				branch.insert(0, bstate);

#if !defined(SRELL_NO_NAMEDCAPTURE)
				if (gno_at_groupbegin != this->number_of_brackets)
				{
					if (!already_pushed)
					{
						cvars.dupranges.push_back(gno_at_groupbegin);
						cvars.dupranges.push_back(this->number_of_brackets);
						already_pushed = true;
					}
					else
						cvars.dupranges.back() = this->number_of_brackets;
				}
#endif
			}

			if (prevbranch_end)
			{
				state_type &pbend = piece[prevbranch_end];

				pbend.next1 = static_cast<std::ptrdiff_t>(branch.size()) + 1;
				pbend.char_num = epsilon_type::et_brnchend;	//  '/'
			}

			piece.append(branch);

			if (curpos == end || *curpos == meta_char::mc_rbracl)
				break;

			//  *curpos == '|'

			prevbranch_end = piece.size();
			bstate.next2 = 0;
			piece.push_back(bstate);

			++curpos;
		}
		return true;
	}

	bool make_branch(state_array &branch, re_quantifier &branchsize, const ui_l32 *&curpos, const ui_l32 *const end, cvars_type &cvars)
	{
		state_array piece;
		state_array piece_with_quantifier;
		re_quantifier quantifier;
		range_pairs tmpcc;
		state_type astate;
		posdata_holder pos;

		branchsize.reset(0);

		for (;;)
		{
			if (curpos == end || *curpos == meta_char::mc_bar || *curpos == meta_char::mc_rbracl)	//  '|', ')'.
				return true;

			piece.clear();
			piece_with_quantifier.clear();

			astate.reset(st_character, *curpos++);

			switch (astate.char_num)
			{
			case meta_char::mc_rbraop:	//  '('
				if (!parse_group(piece, astate.quantifier, curpos, end, cvars))
					return false;
				goto AFTER_PIECE_SET;

			case meta_char::mc_sbraop:	//  '['
				pos.clear();

				if (!parse_unicharset(pos, curpos, end, cvars))
					return false;

				if (pos.may_contain_strings())
					goto ADD_POS;

				tmpcc.swap(pos.ranges);

				astate.char_num = tmpcc.consists_of_one_character();

				if (astate.char_num != constants::invalid_u32value)
				{
					if (astate.char_num & masks::cfolded)
					{
						astate.char_num ^= masks::cfolded;
						this->NFA_states[0].flags |= astate.flags = sflags::icase;
					}
					astate.type = st_character;
				}
				else
				{
					astate.type = st_character_class;
					astate.char_num = this->character_class.register_newclass(tmpcc);
				}

				goto SKIP_ICASE_CHECK_FOR_CHAR;

			case meta_char::mc_escape:	//  '\\'
				if (curpos == end)
					return this->set_error(regex_constants::error_escape);

				astate.char_num = *curpos;

				if (astate.char_num >= char_alnum::ch_1 && astate.char_num <= char_alnum::ch_9)	//  \1, \9.
				{
					astate.char_num = translate_numbers(curpos, end, 10, 0, 0, 0xfffffffe);
						//  22.2.1.1 Static Semantics: Early Errors: ... >= 2**32 - 1.

					if (astate.char_num == constants::invalid_u32value)
						return this->set_error(regex_constants::error_escape);

					astate.flags = 0u;

#if !defined(SRELL_NO_NAMEDCAPTURE)
					BACKREF_POSTPROCESS:
#endif
					astate.next2 = 1;
					astate.type = st_backreference;
					astate.quantifier.atleast = 0;

					cvars.backref_used = true;

					if (cvars.is_icase())
						astate.flags |= sflags::icase;

					break;
				}

				++curpos;

				switch (astate.char_num)
				{
				case char_alnum::ch_B:	//  \B.
					astate.flags = sflags::is_not;
					//@fallthrough@

				case char_alnum::ch_b:	//  \b.
					astate.type = st_boundary;	//  \b, \B.
					astate.quantifier.reset(0);
					astate.char_num = static_cast<ui_l32>(!cvars.is_icase() ? re_character_class::word : re_character_class::icase_word);	//  \w, \W.
					break;

				case char_alnum::ch_A:	//  \A.
					goto PUSH_CARET;

				case char_alnum::ch_z:	//  \z.
					goto PUSH_DOLLAR;

				case char_alnum::ch_Z:	//  \Z.
				{
					//  "(?=(?:\r\n?|[\n\u2028\u2029])?\z)"
					static const ui_l32 escZ[] = { 0x28, 0x3f, 0x3d, 0x28, 0x3f, 0x3a, 0x0d, 0x0a, 0x3f, 0x7c, 0x5b, 0x0a, 0x2028, 0x2029, 0x5d, 0x29, 0x3f, 0x5c, 0x7a, 0x29 };
					const ui_l32 *begin = escZ;
					if (!make_nfa_states(piece, astate.quantifier, begin, begin + 20, cvars))
						return false;
					astate.quantifier.reset(0);
					goto AFTER_PIECE_SET;
				}

#if !defined(SRELL_NO_NAMEDCAPTURE)
				case char_alnum::ch_k:	//  \k.
					if (curpos == end || *curpos != meta_char::mc_lt)
						return this->set_error(regex_constants::error_escape);
					else
					{
						const gname_string groupname = get_groupname(++curpos, end, cvars);

						if (groupname.size() == 0)
							return false;

						astate.flags = sflags::backrefno_unresolved;
						astate.char_num = static_cast<ui_l32>(cvars.unresolved_gnames.size() + 1);
						astate.char_num = cvars.unresolved_gnames.assign_number(groupname, astate.char_num);
						goto BACKREF_POSTPROCESS;
					}
#endif
				default:
					pos.clear();
					if (!translate_escape(pos, astate, curpos, end, false, cvars))
						return false;

					if (pos.may_contain_strings())
					{
						ADD_POS:
						transform_seqdata(piece, pos);
						astate.quantifier.set(pos.length.first, pos.length.second);
						goto AFTER_PIECE_SET;
					}

					if (astate.type == st_character_class)
						astate.char_num = this->character_class.register_newclass(pos.ranges);
				}

				break;

			case meta_char::mc_period:	//  '.'
				astate.type = st_character_class;
#if !defined(SRELL_NO_SINGLELINE)
				if (cvars.is_dotall())
				{
					astate.char_num = static_cast<ui_l32>(re_character_class::dotall);
				}
				else
#endif
				{
					this->character_class.copy_to(tmpcc, static_cast<ui_l32>(re_character_class::newline));

					tmpcc.negation();
					astate.char_num = this->character_class.register_newclass(tmpcc);
				}
				break;

			case meta_char::mc_caret:	//  '^'
				if (cvars.is_multiline())
					astate.flags = sflags::multiline;
				PUSH_CARET:
				astate.type = st_bol;
				astate.char_num = static_cast<ui_l32>(re_character_class::newline);
				astate.quantifier.reset(0);
				break;

			case meta_char::mc_dollar:	//  '$'
				if (cvars.is_multiline())
					astate.flags = sflags::multiline;
				PUSH_DOLLAR:
				astate.type = st_eol;
				astate.char_num = static_cast<ui_l32>(re_character_class::newline);
				astate.quantifier.reset(0);
				break;

			case meta_char::mc_astrsk:	//  '*'
			case meta_char::mc_plus:	//  '+'
			case meta_char::mc_query:	//  '?'
			case meta_char::mc_cbraop:	//  '{'
				return this->set_error(regex_constants::error_badrepeat);

			case meta_char::mc_cbracl:	//  '}'
				return this->set_error(regex_constants::error_brace);

			case meta_char::mc_sbracl:	//  ']'
				return this->set_error(regex_constants::error_brack);

			default:;
			}

			if (astate.type == st_character && (cvars.soflags & regex_constants::icase))
			{
				const ui_l32 cf = unicode_case_folding::try_casefolding(astate.char_num);

				if (cf != constants::invalid_u32value)
				{
					astate.char_num = cf;
					this->NFA_states[0].flags |= astate.flags = sflags::icase;
				}
			}

			SKIP_ICASE_CHECK_FOR_CHAR:

			piece.push_back(astate);
			AFTER_PIECE_SET:

			if (piece.size())
			{
				const state_type &firststate = piece[0];

				quantifier.reset();

				if (firststate.has_quantifier() && curpos != end)
				{
					switch (*curpos)
					{
					case meta_char::mc_astrsk:	//  '*'
						--quantifier.atleast;
						//@fallthrough@

					case meta_char::mc_plus:	//  '+'
						quantifier.set_infinity();
						break;

					case meta_char::mc_query:	//  '?'
						--quantifier.atleast;
						break;

					case meta_char::mc_cbraop:	//  '{'
						++curpos;
						quantifier.atleast = translate_numbers(curpos, end, 10, 1, 0, constants::max_u32value);

						if (quantifier.atleast == constants::invalid_u32value)
							return this->set_error(regex_constants::error_brace);

						if (curpos == end)
							return this->set_error(regex_constants::error_brace);

						if (*curpos == meta_char::mc_comma)	//  ','
						{
							++curpos;
							quantifier.atmost = translate_numbers(curpos, end, 10, 1, 0, constants::max_u32value);

							if (quantifier.atmost == constants::invalid_u32value)
								quantifier.set_infinity();

							if (!quantifier.is_valid())
								return this->set_error(regex_constants::error_badbrace);
						}
						else
							quantifier.atmost = quantifier.atleast;

						if (curpos == end || *curpos != meta_char::mc_cbracl)	//  '}'
							return this->set_error(regex_constants::error_brace);

						//  *curpos == '}'
						break;

					default:
						goto AFTER_GREEDINESS_CHECK;
					}

					if (++curpos != end && *curpos == meta_char::mc_query)	//  '?'
					{
						quantifier.is_greedy = 0u;
						++curpos;
					}
					AFTER_GREEDINESS_CHECK:;
				}

				if (piece.size() == 2 && firststate.is_ncgroup_open())
				{
					//  (?:) alone or followed by a quantifier.
//					piece_with_quantifier += piece;
					;	//  Does nothing.
				}
				else if (!combine_piece_with_quantifier(piece_with_quantifier, piece, quantifier, astate.quantifier))
					return false;

				astate.quantifier.multiply(quantifier);
				branchsize.add(astate.quantifier);

#if !defined(SRELL_FIXEDWIDTHLOOKBEHIND)

				if (!cvars.is_back())
					branch.append(piece_with_quantifier);
				else
					branch.insert(0, piece_with_quantifier);
#else
				branch.append(piece_with_quantifier);
#endif
			}
		}
	}

	//  '('.

	bool parse_group(state_array &piece, re_quantifier &piecesize, const ui_l32 *&curpos, const ui_l32 *const end, cvars_type &cvars)
	{
		const ui_l32 originalflags(cvars.soflags);
		state_type rbstate;

		if (curpos == end)
			return this->set_error(regex_constants::error_paren);

		rbstate.reset(st_roundbracket_open);

		if (*curpos == meta_char::mc_query)	//  '?'
		{
			if (++curpos == end)
				return this->set_error(regex_constants::error_paren);

			rbstate.char_num = *curpos;

			if (rbstate.char_num == meta_char::mc_lt)	//  '<'
			{
				if (++curpos == end)
					return this->set_error(regex_constants::error_paren);

				rbstate.char_num = *curpos;

				if (rbstate.char_num != meta_char::mc_eq && rbstate.char_num != meta_char::mc_exclam)
				{
#if !defined(SRELL_NO_NAMEDCAPTURE)
					const gname_string groupname = get_groupname(curpos, end, cvars);

					if (groupname.size() == 0)
						return false;

					if (!this->namedcaptures.push_back(groupname, this->number_of_brackets, cvars.dupranges))
						return this->set_error(regex_constants::error_backref);

					goto CGROUP;
#else
					return this->set_error(regex_constants::error_paren);
#endif	//  !defined(SRELL_NO_NAMEDCAPTURE)
				}
				//  "(?<=" or "(?<!"
			}
			else
				rbstate.quantifier.is_greedy = 0;
				//  0: Other than lookbehind assertions.
				//  1: Lookbehind.

			switch (rbstate.char_num)
			{
			case meta_char::mc_exclam:	//  '!'
				rbstate.flags = sflags::is_not;
				//@fallthrough@

			case meta_char::mc_eq:	//  '='
#if !defined(SRELL_FIXEDWIDTHLOOKBEHIND)
				cvars.soflags = rbstate.quantifier.is_greedy ? (cvars.soflags | regex_constants::back_) : (cvars.soflags & ~regex_constants::back_);
#endif

#if defined(SRELL_ENABLE_GT)
				//@fallthrough@
			case meta_char::mc_gt:
#endif
				rbstate.type = st_lookaround_open;
				rbstate.next2 = 1;
				rbstate.quantifier.atleast = this->number_of_brackets;
				piece.push_back(rbstate);
				rbstate.next1 = 1;
				rbstate.next2 = 0;
				rbstate.type = st_lookaround_pop;
				break;

			default:
				{
					const u32size_type boffset = curpos - cvars.begin;
					ui_l32 to_be_modified = 0;
					ui_l32 modified = 0;
					ui_l32 localflags = cvars.soflags;
					bool negate = false;

					for (;;)
					{
						switch (rbstate.char_num)
						{
#if !defined(SRELLDBG_NO_MODIFIERS)
						case meta_char::mc_colon:	//  ':'
							//  (?ims-ims:...)
							if (modified)
							{
								if (modified & (regex_constants::unicodesets | regex_constants::sticky | regex_constants::nosubs))
									goto ERROR_PAREN;

								goto COLON_FOUND;
							}
							//  "(?-:"
							goto ERROR_MODIFIER;
#endif
#if !defined(SRELL_NO_UBMOD)
						case meta_char::mc_rbracl:	//  ')'
							if (modified)
							{
								cvars.soflags = localflags;
								if (boffset == 2)
								{
									this->soflags = localflags;
								}
								else if (modified & regex_constants::sticky)
									goto ERROR_MODIFIER;

								if (boffset == 2)	//  Restricts so that unbounded forms (?ims-ims) can be used only at the beginning of an expression.
								{
									++curpos;
									return true;
								}
							}
							//  "(?)" or "(?-)"
							goto ERROR_MODIFIER;
#endif
						case meta_char::mc_minus:	//  '-'
							if (negate)
								goto ERROR_MODIFIER;
							negate = true;
							break;

						case char_alnum::ch_i:	//  'i'
							to_be_modified = regex_constants::icase;
							goto TRY_MODIFICATION;

						case char_alnum::ch_m:	//  'm'
							to_be_modified = regex_constants::multiline;
							goto TRY_MODIFICATION;

						case char_alnum::ch_s:	//  's'
							to_be_modified = regex_constants::dotall;
							goto TRY_MODIFICATION;

						case char_alnum::ch_v:	//  'v'
							to_be_modified = regex_constants::unicodesets;
							goto TRY_MODIFICATION;

						case char_alnum::ch_y:	//  'y'
							to_be_modified = regex_constants::sticky;
							goto TRY_MODIFICATION;

						case char_alnum::ch_n:	//  'n'
							to_be_modified = regex_constants::nosubs;
							goto TRY_MODIFICATION;

						default:
							ERROR_PAREN:
							return this->set_error(regex_constants::error_paren);

							TRY_MODIFICATION:
							if (modified & to_be_modified)
							{
								ERROR_MODIFIER:
								return this->set_error(regex_constants::error_modifier);
							}

							modified |= to_be_modified;
							if (!negate)
								localflags |= to_be_modified;
							else
								localflags &= ~to_be_modified;
						}

						if (++curpos == end)
							goto ERROR_PAREN;

						rbstate.char_num = *curpos;
					}
#if !defined(SRELLDBG_NO_MODIFIERS)
					COLON_FOUND:;
					cvars.soflags = localflags;
#endif
				}
				//@fallthrough@

			case meta_char::mc_colon:
				++curpos;
				goto NCGROUP;
			}

			++curpos;
			piece.push_back(rbstate);
		}
		else
		{
			if (cvars.is_nosubs())
			{
				NCGROUP:
				rbstate.type = st_epsilon;
				rbstate.char_num = epsilon_type::et_ncgopen;
				rbstate.quantifier.atleast = this->number_of_brackets;
			}
			else
			{
#if !defined(SRELL_NO_NAMEDCAPTURE)
				CGROUP:
#endif
				if (this->number_of_brackets > constants::max_u32value)
					return this->set_error(regex_constants::error_complexity);

				rbstate.char_num = this->number_of_brackets++;
				rbstate.next1 = 2;
				rbstate.next2 = 1;
				rbstate.quantifier.atleast = this->number_of_brackets;
				piece.push_back(rbstate);

				rbstate.type  = st_roundbracket_pop;
				rbstate.next1 = 0;
				rbstate.next2 = 0;
			}
			piece.push_back(rbstate);
		}

#if !defined(SRELL_NO_NAMEDCAPTURE)
		const u32size_type dzsize = cvars.dupranges.size();
#endif

		if (++cvars.depth > SRELL_MAX_DEPTH)
			return this->set_error(regex_constants::error_complexity);

		if (!make_nfa_states(piece, piecesize, curpos, end, cvars))
			return false;

		//  end or ')'?
		if (curpos == end)
			return this->set_error(regex_constants::error_paren);

		--cvars.depth;
		++curpos;

#if !defined(SRELL_NO_NAMEDCAPTURE)
		cvars.dupranges.resize(dzsize);
#endif
		cvars.soflags = originalflags;

		state_type &firststate = piece[0];

		firststate.quantifier.atmost = this->number_of_brackets - 1;

		switch (rbstate.type)
		{
		case st_epsilon:
			if (piece.size() == 2)	//  ':' + something.
			{
				piece.erase(0);
				return true;
			}

			firststate.quantifier.is_greedy = piecesize.atleast != 0u;
			rbstate.char_num = epsilon_type::et_ncgclose;
			break;

		case st_lookaround_pop:
#if defined(SRELL_FIXEDWIDTHLOOKBEHIND)
			if (firststate.quantifier.is_greedy)	//  > 0 means lookbehind.
			{
				if (!piecesize.is_same() || piecesize.is_infinity())
					return this->set_error(regex_constants::error_lookbehind);

				firststate.quantifier.is_greedy = piecesize.atleast;
			}
#endif

#if defined(SRELL_ENABLE_GT)
			if (firststate.char_num != meta_char::mc_gt)
#endif
				piecesize.reset(0);

			firststate.next1 = static_cast<std::ptrdiff_t>(piece.size()) + 1;
			piece[1].quantifier.atmost = firststate.quantifier.atmost;

			rbstate.type  = st_lookaround_close;
			rbstate.next1 = 0;
			break;

		default:
			rbstate.type = st_roundbracket_close;
			rbstate.next1 = 1;
//			rbstate.next2 = 0;

			piece[1].quantifier.atmost = firststate.quantifier.atmost;
			firststate.quantifier.is_greedy = piecesize.atleast != 0u;
		}

		piece.push_back(rbstate);
		return true;
	}

	bool combine_piece_with_quantifier(state_array &piece_with_quantifier, state_array &piece, const re_quantifier &quantifier, const re_quantifier &piecesize)
	{
		if (quantifier.atmost == 0)
			return true;

		state_type &firststate = piece[0];
		state_type qstate;

		qstate.reset(st_epsilon, firststate.is_character_or_class()
			? epsilon_type::et_ccastrsk
			: epsilon_type::et_dfastrsk);
		qstate.quantifier = quantifier;

		if (quantifier.atmost == 1)
		{
			if (quantifier.atleast == 0)
			{
				qstate.next2 = static_cast<std::ptrdiff_t>(piece.size()) + 1;
				if (!quantifier.is_greedy)
				{
					qstate.next1 = qstate.next2;
					qstate.next2 = 1;
				}

				piece[piece.size() - 1].quantifier = quantifier;
				piece_with_quantifier.push_back(qstate);
			}

			if (firststate.type == st_roundbracket_open)
				firststate.quantifier.atmost = piece[1].quantifier.atmost = 0;

			piece_with_quantifier.append(piece);
			return true;
		}

		//  atmost >= 2

#if !defined(SRELLDBG_NO_SIMPLEEQUIV)

		//  A counter requires at least 6 states: save, restore, check, inc, dec, ATOM(s).
		//  A character or charclass quantified by one of these has a simple equivalent representation:
		//  a{0,2}  1.epsilon(2|5), 2.CHorCL(3), 3.epsilon(4|5), 4.CHorCL(5), [5].
		//  a{0,3}  1.epsilon(2|7), 2.CHorCL(3), 3.epsilon(4|7), 4.CHorCL(5), 5.epsilon(6|7), 6.CHorCL(7), [7].
		//  a{1,2}  1.CHorCL(2), 2.epsilon(3|4), 3.CHorCL(4), [4].
		//  a{1,3}  1.CHorCL(2), 2.epsilon(3|6), 3.CHorCL(4), 4.epsilon(5|6), 5.CHorCL(6), [6].
		//  a{2,3}  1.CHorCL(2), 2.CHorCL(3), 3.epsilon(4|5), 4.CHorCL(5), [5].
		//  a{2,4}  1.CHorCL(2), 2.CHorCL(3), 3.epsilon(4|7), 4.CHorCL(5), 5.epsilon(6|7), 6.CHorCL(7), [7].
		if (qstate.char_num == epsilon_type::et_ccastrsk && quantifier.has_simple_equivalence())
		{
			const state_size_type branchsize = piece.size() + 1;

			for (ui_l32 i = 0; i < quantifier.atleast; ++i)
				piece_with_quantifier.append(piece);

			firststate.quantifier.set(0, 1, quantifier.is_greedy);

			qstate.next2 = (quantifier.atmost - quantifier.atleast) * branchsize;
			if (!quantifier.is_greedy)
			{
				qstate.next1 = qstate.next2;
				qstate.next2 = 1;
			}

			for (ui_l32 i = quantifier.atleast; i < quantifier.atmost; ++i)
			{
				piece_with_quantifier.push_back(qstate);
				piece_with_quantifier.append(piece);
				quantifier.is_greedy ? (qstate.next2 -= branchsize) : (qstate.next1 -= branchsize);
			}
			return true;
		}
#endif	//  !defined(SRELLDBG_NO_SIMPLEEQUIV)

		if (firststate.type == st_backreference && (firststate.flags & sflags::backrefno_unresolved))
		{
			firststate.quantifier = quantifier;
			qstate.quantifier.set(1, 0);
			goto ADD_CHECKER;
		}
		else if (firststate.is_ncgroup_open() && (piecesize.atleast == 0 || firststate.quantifier.is_valid()))
		{
			qstate.quantifier = firststate.quantifier;
			ADD_CHECKER:

			if (this->number_of_repeats > constants::max_u32value)
				return this->set_error(regex_constants::error_complexity);

			qstate.char_num = this->number_of_repeats++;

			qstate.type = st_repeat_in_pop;
			qstate.next1 = 0;
			qstate.next2 = 0;
			piece.insert(0, qstate);

			qstate.type = st_repeat_in_push;
			qstate.next1 = 2;
			qstate.next2 = 1;
			piece.insert(0, qstate);

			qstate.quantifier = quantifier;
			qstate.type = st_check_0_width_repeat;
			qstate.next2 = 1;
			piece.push_back(qstate);

			if (piecesize.atleast == 0 && piece[2].type != st_backreference)
				goto USE_COUNTER;

			qstate.char_num = epsilon_type::et_dfastrsk;
		}

		qstate.type = st_epsilon;

		if (quantifier.is_asterisk())	//  {0,}
		{
			//  greedy:  1.epsilon(2|4), 2.piece, 3.LAorC0WR(1|0), 4.OutOfLoop.
			//  !greedy: 1.epsilon(4|2), 2.piece, 3.LAorC0WR(1|0), 4.OutOfLoop.
			//  LAorC0WR: LastAtomOfPiece or Check0WidthRepeat.
		}
		else if (quantifier.is_plus())	//  {1,}
		{
#if !defined(SRELLDBG_NO_ASTERISK_OPT)

			if (qstate.char_num == epsilon_type::et_ccastrsk)
			{
				piece_with_quantifier.append(piece);
				--qstate.quantifier.atleast;	//  /.+/ -> /..*/.
			}
			else
#endif
			{
				const ui_l32 backup = qstate.char_num;

				qstate.next1 = 2;
				qstate.next2 = 0;
				qstate.char_num = epsilon_type::et_jmpinlp;
				piece_with_quantifier.push_back(qstate);
				qstate.char_num = backup;
				//  greedy:  1.epsilon(3), 2.epsilon(3|5), 3.piece, 4.LAorC0WR(2|0), 5.OutOfLoop.
				//  !greedy: 1.epsilon(3), 2.epsilon(5|3), 3.piece, 4.LAorC0WR(2|0), 5.OutOfLoop.
			}
		}
		else
		{
#if !defined(SRELLDBG_NO_ASTERISK_OPT)
			if (qstate.char_num == epsilon_type::et_ccastrsk && quantifier.is_infinity())
			{
				if (quantifier.atleast <= 6)
				{
					for (ui_l32 i = 0; i < quantifier.atleast; ++i)
						piece_with_quantifier.append(piece);
					qstate.quantifier.atleast = 0;
					goto APPEND_ATOM;
				}
				qstate.quantifier.atmost = qstate.quantifier.atleast;
			}
#endif	//  !defined(SRELLDBG_NO_ASTERISK_OPT)

			USE_COUNTER:

			if (this->number_of_counters > constants::max_u32value)
				return this->set_error(regex_constants::error_complexity);

			qstate.char_num = this->number_of_counters++;

			qstate.type = st_save_and_reset_counter;
			qstate.next1 = 2;
			qstate.next2 = 1;
			piece_with_quantifier.push_back(qstate);

			qstate.type = st_restore_counter;
			qstate.next1 = 0;
			qstate.next2 = 0;
			piece_with_quantifier.push_back(qstate);
			//  1.save_and_reset_counter(3|2), 2.restore_counter(0|0),

			qstate.type = st_decrement_counter;
			piece.insert(0, qstate);

			qstate.next1 = 2;
			qstate.next2 = piece[1].is_character_or_class() ? 0 : 1;
			qstate.type = st_increment_counter;
			piece.insert(0, qstate);

			qstate.type = st_check_counter;
			//  greedy:  3.check_counter(4|6), 4.piece, 5.LAorC0WR(3|0), 6.OutOfLoop.
			//  !greedy: 3.check_counter(6|4), 4.piece, 5.LAorC0WR(3|0), 6.OutOfLoop.
			//  4.piece = { 4a.increment_counter(4c|4b), 4b.decrement_counter(0|0), 4c.OriginalPiece }.
		}

		APPEND_ATOM:

		const std::ptrdiff_t piece_size = static_cast<std::ptrdiff_t>(piece.size());
		state_type &laststate = piece[piece_size - 1];

		laststate.quantifier = qstate.quantifier;
		laststate.next1 = 0 - piece_size;

		qstate.next1 = 1;
		qstate.next2 = piece_size + 1;
		if (!quantifier.is_greedy)
		{
			qstate.next1 = qstate.next2;
			qstate.next2 = 1;
		}
		piece_with_quantifier.push_back(qstate);
		piece_with_quantifier.append(piece);

#if !defined(SRELLDBG_NO_ASTERISK_OPT)

		if (qstate.quantifier.atmost != quantifier.atmost)
		{
			qstate.type = st_epsilon;
			qstate.char_num = epsilon_type::et_ccastrsk;
			qstate.quantifier.atleast = 0;
			qstate.quantifier.atmost = quantifier.atmost;
			piece.erase(0, piece_size - 1);
			goto APPEND_ATOM;
		}
#endif	//  !defined(SRELLDBG_NO_ASTERISK_OPT)

		return true;
	}

	//  '['.

	bool parse_unicharset(posdata_holder &basepos, const ui_l32 *&curpos, const ui_l32 *const end, cvars_type &cvars)
	{
		if (curpos == end)
			return this->set_error(regex_constants::error_brack);

		const bool is_umode = !cvars.is_vmode();
		const bool invert = (*curpos == meta_char::mc_caret) ? (++curpos, true) : false;	//  '^'
		enum operation_type
		{
			op_init, op_firstcc, op_union, op_intersection, op_subtraction
		};
		operation_type otype = op_init;
		posdata_holder newpos;
		range_pair code_range;
		state_type castate;

		//  ClassSetCharacter ::
		//  \ CharacterEscape[+UnicodeMode]
		//  \ ClassSetReservedPunctuator
		//  \ b

		for (;;)
		{
			if (curpos == end)
				goto ERROR_NOT_CLOSED;

			if (*curpos == meta_char::mc_sbracl)	//   ']'
				break;

			if (!is_umode)
			{
				ui_l32 next2chars = constants::invalid_u32value;

				if (curpos + 1 != end && *curpos == curpos[1])
				{
					switch (*curpos)
					{
					//  ClassSetReservedDoublePunctuator :: one of
					//  && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~
					case char_other::co_amp:	//  '&'
					case meta_char::mc_exclam:	//  '!'
					case meta_char::mc_sharp:	//  '#'
					case meta_char::mc_dollar:	//  '$'
					case char_other::co_perc:	//  '%'
					case meta_char::mc_astrsk:	//  '*'
					case meta_char::mc_plus:	//  '+'
					case meta_char::mc_comma:	//  ','
					case meta_char::mc_period:	//  '.'
					case meta_char::mc_colon:	//  ':'
					case char_other::co_smcln:	//  ';'
					case meta_char::mc_lt:		//  '<'
					case meta_char::mc_eq:		//  '='
					case meta_char::mc_gt:		//  '>'
					case meta_char::mc_query:	//  '?'
					case char_other::co_atmrk:	//  '@'
					case meta_char::mc_caret:	//  '^'
					case char_other::co_grav:	//  '`'
					case char_other::co_tilde:	//  '~'
					case meta_char::mc_minus:	//  '-'
						next2chars = *curpos;
						//@fallthrough@
					default:;
					}
				}

				switch (otype)
				{
				case op_intersection:
					if (next2chars != char_other::co_amp)
						goto ERROR_DOUBLE_PUNCT;
					curpos += 2;
					break;

				case op_subtraction:
					if (next2chars != meta_char::mc_minus)
						goto ERROR_DOUBLE_PUNCT;
					curpos += 2;
					break;

				case op_firstcc:
					if (next2chars == char_other::co_amp)
						otype = op_intersection;
					else if (next2chars == meta_char::mc_minus)
						otype = op_subtraction;
					else if (next2chars == constants::invalid_u32value)
						break;
					else
						goto ERROR_DOUBLE_PUNCT;

					curpos += 2;
					break;

//				case op_union:
//				case op_init:
				default:
					if (next2chars != constants::invalid_u32value)
						goto ERROR_DOUBLE_PUNCT;
				}
			}

			AFTER_OPERATOR:

			if (curpos == end)
				goto ERROR_NOT_CLOSED;

			castate.reset();

			if (!is_umode && *curpos == meta_char::mc_sbraop)	//  '['
			{
				if (++cvars.depth > SRELL_MAX_DEPTH)
					return this->set_error(regex_constants::error_complexity);

				++curpos;
				if (!parse_unicharset(newpos, curpos, end, cvars))
					return false;
				--cvars.depth;
			}
			else if (!get_classatom(newpos, castate, curpos, end, cvars, false))
				return false;

			if (curpos == end)
				goto ERROR_NOT_CLOSED;

			if (otype == op_init)
				otype = op_firstcc;
			else if (otype == op_firstcc)
				otype = op_union;

			if (castate.type == st_character_class)
			{
				//  In the u-mode, '-' following a character class is an error except "-]", immediately before ']'.
				if (is_umode && curpos != end && *curpos == meta_char::mc_minus)	//  '-'
					if ((curpos + 1) != end && curpos[1] != meta_char::mc_sbracl)
						goto ERROR_BROKEN_RANGE;
			}
			else if (castate.type == st_character)
			{
				if (!newpos.has_data())
				{
					code_range.set(castate.char_num);

					if (otype <= op_union)
					{
						if (*curpos == meta_char::mc_minus && (curpos + 1) != end && curpos[1] != meta_char::mc_sbracl)	//  '-'
						{
							++curpos;

							if (!is_umode && otype < op_union && *curpos == meta_char::mc_minus)	//  '-'
							{
								otype = op_subtraction;
								++curpos;
								basepos.ranges.join(code_range);
								goto AFTER_OPERATOR;
							}

							if (!get_classatom(newpos, castate, curpos, end, cvars, true))
								return false;

							otype = op_union;
							code_range.second = castate.char_num;
							if (!code_range.is_range_valid())
								goto ERROR_BROKEN_RANGE;
						}
					}

					newpos.ranges.join(code_range);
					if (cvars.is_icase())
						newpos.ranges.make_caseunfoldedcharset();
				}
			}

			if (is_umode)
				basepos.ranges.merge(newpos.ranges);
			else
			{
				switch (otype)
				{
				case op_union:
					basepos.do_union(newpos);
					break;

				case op_intersection:
					basepos.do_and(newpos);
					break;

				case op_subtraction:
					basepos.do_subtract(newpos);
					break;

//				case op_firstcc:
				default:
					basepos.swap(newpos);
				}
			}
		}

		//  *curpos == ']'
		++curpos;

		if (invert)
		{
			if (basepos.may_contain_strings())
				return this->set_error(regex_constants::error_complement);

			basepos.ranges.negation();
		}

		return true;

		ERROR_NOT_CLOSED:
		return this->set_error(regex_constants::error_brack);

		ERROR_BROKEN_RANGE:
		return this->set_error(regex_constants::error_range);

		ERROR_DOUBLE_PUNCT:
		return this->set_error(regex_constants::error_operator);
	}

	bool get_classatom(
		posdata_holder &pos,
		state_type &castate,
		const ui_l32 *&curpos,
		const ui_l32 *const end,
		const cvars_type &cvars,
		const bool no_ccesc
	)
	{
		pos.clear();

		castate.char_num = *curpos++;

		switch (castate.char_num)
		{
		//  ClassSetSyntaxCharacter :: one of
		//  ( ) [ ] { } / - \ |
		case meta_char::mc_rbraop:	//  '('
		case meta_char::mc_rbracl:	//  ')'
		case meta_char::mc_sbraop:	//  '['
		case meta_char::mc_sbracl:	//  ']'
		case meta_char::mc_cbraop:	//  '{'
		case meta_char::mc_cbracl:	//  '}'
		case char_other::co_slash:	//  '/'
		case meta_char::mc_minus:	//  '-'
		case meta_char::mc_bar:		//  '|'
			return !cvars.is_vmode() ? true : this->set_error(regex_constants::error_noescape);

		case meta_char::mc_escape:	//  '\\'
			break;

		default:
			return true;
		}

		if (curpos == end)
			return this->set_error(regex_constants::error_escape);

		castate.char_num = *curpos++;

		switch (castate.char_num)
		{
		case char_alnum::ch_b:
			castate.char_num = char_ctrl::cc_bs;	//  '\b' 0x08:BS
			//@fallthrough@

		case meta_char::mc_minus:	//  '-'
			return true;

		//  ClassSetReservedPunctuator :: one of
		//  & - ! # % , : ; < = > @ ` ~
		case char_other::co_amp:	//  '&'
		case meta_char::mc_exclam:	//  '!'
		case meta_char::mc_sharp:	//  '#'
		case char_other::co_perc:	//  '%'
		case meta_char::mc_comma:	//  ','
		case meta_char::mc_colon:	//  ':'
		case char_other::co_smcln:	//  ';'
		case meta_char::mc_lt:		//  '<'
		case meta_char::mc_eq:		//  '='
		case meta_char::mc_gt:		//  '>'
		case char_other::co_atmrk:	//  '@'
		case char_other::co_grav:	//  '`'
		case char_other::co_tilde:	//  '~'
			if (cvars.is_vmode())
				return true;
			break;

#if !defined(SRELL_NO_UNICODE_POS)
		case char_alnum::ch_q:	//  '\\q'
			if (cvars.is_vmode() && !no_ccesc)
			{
				if (curpos == end || *curpos != meta_char::mc_cbraop)	//  '{'
					return this->set_error(regex_constants::error_escape);

				u32array seqs;
				u32array curseq;
				posdata_holder dummypos;
				state_type castate2;

				++curpos;

				for (;;)
				{
					if (curpos == end)
						return this->set_error(regex_constants::error_escape);

					if (*curpos == meta_char::mc_bar || *curpos == meta_char::mc_cbracl)	//  '|' or '}'.
					{
						const ui_l32 seqlen = static_cast<ui_l32>(curseq.size());

						if (seqlen <= 1)
						{
							seqs.push_back_c(2);
							seqs.push_back_c(seqlen != 0 ? curseq[0] : constants::ccstr_empty);
						}
						else	//  >= 2
						{
							seqs.push_back_c(seqlen + 1);
							seqs.append(curseq);
						}

						if (*curpos == meta_char::mc_cbracl)	//  '}'
							break;

						curseq.clear();
						++curpos;
					}
					else
					{
						castate2.reset();
						if (!get_classatom(dummypos, castate2, curpos, end, cvars, true))
							return false;

						curseq.push_back_c(castate2.char_num);
					}
				}

				++curpos;
#if !defined(SRELL_FIXEDWIDTHLOOKBEHIND)
				pos.split_seqs_and_ranges(seqs, cvars.is_icase(), cvars.is_back());
#else
				pos.split_seqs_and_ranges(seqs, cvars.is_icase(), false);
#endif

				return true;
			}
			//@fallthrough@
#endif	//  !defined(SRELL_NO_UNICODE_POS)

		default:;
		}

		return translate_escape(pos, castate, curpos, end, no_ccesc, cvars);
	}

	bool translate_escape(posdata_holder &pos, state_type &eastate, const ui_l32 *&curpos, const ui_l32 *const end, const bool no_ccesc, const cvars_type &cvars)
	{
		if (!no_ccesc)
		{
			//  Predefined classes.
			switch (eastate.char_num)
			{
			case char_alnum::ch_D:	//  \D.
				eastate.flags = sflags::is_not;
				//@fallthrough@

			case char_alnum::ch_d:	//  \d.
				eastate.char_num = static_cast<ui_l32>(re_character_class::digit);	//  \d, \D.
				break;

			case char_alnum::ch_S:	//  \S.
				eastate.flags = sflags::is_not;
				//@fallthrough@

			case char_alnum::ch_s:	//  \s.
				eastate.char_num = static_cast<ui_l32>(re_character_class::space);	//  \s, \S.
				break;

			case char_alnum::ch_W:	//  \W.
				eastate.flags = sflags::is_not;
				//@fallthrough@

			case char_alnum::ch_w:	//  \w.
				eastate.char_num = static_cast<ui_l32>(!cvars.is_icase() ? re_character_class::word : re_character_class::icase_word);	//  \w, \W.
				break;

#if !defined(SRELL_NO_UNICODE_PROPERTY)
			case char_alnum::ch_P:	//  \P{...}
				eastate.flags = sflags::is_not;
				//@fallthrough@

			case char_alnum::ch_p:	//  \p{...}
			{
				u32view pname;
				u32view pvalue;

				if (curpos == end || *curpos != meta_char::mc_cbraop)	//  '{'
					return this->set_error(regex_constants::error_property);

				const bool digit_found = get_property_name_or_value(pvalue, ++curpos, end);

				if (pvalue.size() == 0)
					return this->set_error(regex_constants::error_property);

				if (!digit_found)
				{
					if (curpos == end)
						return this->set_error(regex_constants::error_property);

					if (*curpos == meta_char::mc_eq)	//  '='
					{
						pname = pvalue;
						get_property_name_or_value(pvalue, ++curpos, end);
						if (pvalue.size() == 0)
							return this->set_error(regex_constants::error_property);
					}
				}

				if (curpos == end || *curpos != meta_char::mc_cbracl)	//  '}'
					return this->set_error(regex_constants::error_property);

				++curpos;

				eastate.char_num = this->character_class.get_propertynumber(pname, pvalue);

				if (eastate.char_num == up_constants::error_property)
					return this->set_error(regex_constants::error_property);

				if (!this->character_class.is_pos(eastate.char_num))
				{
					pos.clear();

					this->character_class.load_upranges(pos.ranges, eastate.char_num);

					if (cvars.is_vmode() && cvars.is_icase() && eastate.char_num >= static_cast<ui_l32>(re_character_class::number_of_predefcls))
						pos.ranges.make_caseunfoldedcharset();

					if (eastate.flags)	//  is_not.
					{
						pos.ranges.negation();
						eastate.flags = 0u;
					}

					if (!cvars.is_vmode() && cvars.is_icase())
						pos.ranges.make_caseunfoldedcharset();

					eastate.type = st_character_class;
					eastate.quantifier.reset(1);
				}
				else
				{
#if !defined(SRELL_NO_UNICODE_POS)
					if (!cvars.is_vmode())
#endif
						return this->set_error(regex_constants::error_property);

					u32array sequences;

					this->character_class.get_prawdata(sequences, eastate.char_num);
#if !defined(SRELL_FIXEDWIDTHLOOKBEHIND)
					pos.split_seqs_and_ranges(sequences, cvars.is_icase(), cvars.is_back());
#else
					pos.split_seqs_and_ranges(sequences, cvars.is_icase(), false);
#endif

					eastate.quantifier.set(pos.length.first, pos.length.second);

					if (eastate.flags)	//  is_not.
						return this->set_error(regex_constants::error_complement);
				}
				return true;
			}
#endif	//  !defined(SRELL_NO_UNICODE_PROPERTY)

			default:
				goto CHARACTER_ESCAPE;
			}

			range_pairs predefclass(this->character_class.view(eastate.char_num));

			if (eastate.flags)	//  is_not.
				predefclass.negation();

			pos.ranges.merge(predefclass);

			eastate.flags = 0u;
			eastate.type = st_character_class;
			return true;
		}

		CHARACTER_ESCAPE:

		switch (eastate.char_num)
		{
		case char_alnum::ch_t:
			eastate.char_num = char_ctrl::cc_htab;	//  '\t' 0x09:HT
			break;

		case char_alnum::ch_n:
			eastate.char_num = char_ctrl::cc_nl;	//  '\n' 0x0a:LF
			break;

		case char_alnum::ch_v:
			eastate.char_num = char_ctrl::cc_vtab;	//  '\v' 0x0b:VT
			break;

		case char_alnum::ch_f:
			eastate.char_num = char_ctrl::cc_ff;	//  '\f' 0x0c:FF
			break;

		case char_alnum::ch_r:
			eastate.char_num = char_ctrl::cc_cr;	//  '\r' 0x0d:CR
			break;

		case char_alnum::ch_c:	//  \cX
			if (curpos != end)
			{
				eastate.char_num = static_cast<ui_l32>(*curpos | masks::asc_icase);

				if (eastate.char_num >= char_alnum::ch_a && eastate.char_num <= char_alnum::ch_z)
				{
					eastate.char_num = static_cast<ui_l32>(*curpos++ & 0x1f);
					break;
				}
			}
			return this->set_error(regex_constants::error_escape);

		case char_alnum::ch_0:
			eastate.char_num = char_ctrl::cc_nul;	//  '\0' 0x00:NUL
			if (curpos != end && *curpos >= char_alnum::ch_0 && *curpos <= char_alnum::ch_9)
				return this->set_error(regex_constants::error_escape);
			break;

		case char_alnum::ch_x:	//  \xhh
			eastate.char_num = translate_numbers(curpos, end, 16, 2, 2, 0xff);
			break;

		case char_alnum::ch_u:	//  \uhhhh, \u{h~hhhhhh}
			eastate.char_num = parse_escape_u(curpos, end);
			break;

		//  SyntaxCharacter, and '/'.
		case meta_char::mc_caret:	//  '^'
		case meta_char::mc_dollar:	//  '$'
		case meta_char::mc_escape:	//  '\\'
		case meta_char::mc_period:	//  '.'
		case meta_char::mc_astrsk:	//  '*'
		case meta_char::mc_plus:	//  '+'
		case meta_char::mc_query:	//  '?'
		case meta_char::mc_rbraop:	//  '('
		case meta_char::mc_rbracl:	//  ')'
		case meta_char::mc_sbraop:	//  '['
		case meta_char::mc_sbracl:	//  ']'
		case meta_char::mc_cbraop:	//  '{'
		case meta_char::mc_cbracl:	//  '}'
		case meta_char::mc_bar:		//  '|'
		case char_other::co_slash:	//  '/'
			break;

		default:
			eastate.char_num = constants::invalid_u32value;
		}

		if (eastate.char_num == constants::invalid_u32value)
			return this->set_error(regex_constants::error_escape);

		return true;
	}

	ui_l32 parse_escape_u(const ui_l32 *&curpos, const ui_l32 *const end) const
	{
		ui_l32 ucp;

		if (curpos == end)
			return constants::invalid_u32value;

		if (*curpos == meta_char::mc_cbraop)
		{
			ucp = translate_numbers(++curpos, end, 16, 1, 0, constants::unicode_max_codepoint);

			if (curpos == end || *curpos != meta_char::mc_cbracl)
				return constants::invalid_u32value;

			++curpos;
		}
		else
		{
			ucp = translate_numbers(curpos, end, 16, 4, 4, 0xffff);

			if (ucp >= 0xd800 && ucp <= 0xdbff && (curpos + 6) <= end && *curpos == meta_char::mc_escape && curpos[1] == char_alnum::ch_u)
			{
				const ui_l32 *la = curpos + 2;
				const ui_l32 nextucp = translate_numbers(la, end, 16, 4, 4, 0xffff);

				if (nextucp >= 0xdc00 && nextucp <= 0xdfff)
				{
					curpos = la;
					ucp = ((ucp << 10) + nextucp) - 0x35fdc00;	//  - ((0xd800 << 10) + 0xdc00) + 0x10000.
				}
			}
		}
		return ucp;
	}

#if !defined(SRELL_NO_UNICODE_PROPERTY)

	bool get_property_name_or_value(u32view &name_or_value, const ui_l32 *&curpos, const ui_l32 *const end) const
	{
		bool number_found = false;

		name_or_value.data_ = curpos;

		for (;; ++curpos)
		{
			if (curpos == end)
				break;

			const ui_l32 curchar = *curpos;

			if (curchar >= char_alnum::ch_A && curchar <= char_alnum::ch_Z)
				;
			else if (curchar >= char_alnum::ch_a && curchar <= char_alnum::ch_z)
				;
			else if (curchar == char_other::co_ll)	//  '_'
				;
			else if (curchar >= char_alnum::ch_0 && curchar <= char_alnum::ch_9)
				number_found = true;
			else
				break;
		}

		name_or_value.size_ = curpos - name_or_value.data_;

		//  A string containing a digit cannot be a property name.
		return number_found;
	}

#endif	//  !defined(SRELL_NO_UNICODE_PROPERTY)

#if !defined(SRELL_NO_NAMEDCAPTURE)

	gname_string get_groupname(const ui_l32 *&curpos, const ui_l32 *const end, cvars_type &cvars)
	{
		charT mbstr[utf_traits::maxseqlen];
		gname_string groupname;

#if !defined(SRELL_NO_UNICODE_PROPERTY)
		cvars.idchecker.setup();
#else
		static_cast<void>(cvars);
#endif
		for (;;)
		{
			if (curpos == end)
			{
				groupname.clear();
				break;
			}

			ui_l32 curchar = *curpos++;

			if (curchar == meta_char::mc_gt)	//  '>'
				break;

			if (curchar == meta_char::mc_escape && curpos != end && *curpos == char_alnum::ch_u)	//  '\\', 'u'.
				curchar = parse_escape_u(++curpos, end);

#if defined(SRELL_NO_UNICODE_PROPERTY)
			if (curchar != meta_char::mc_escape)
#else
			if (cvars.idchecker.is_identifier(curchar, groupname.size() != 0))
#endif
				;	//  OK.
			else
				curchar = constants::invalid_u32value;

			if (curchar == constants::invalid_u32value)
			{
				groupname.clear();
				break;
			}

			const ui_l32 seqlen = utf_traits::to_codeunits(mbstr, curchar);

			groupname.append(mbstr, seqlen);
		}

		if (groupname.size() == 0)
			this->set_error(regex_constants::error_escape);

		return groupname;
	}
#endif	//  !defined(SRELL_NO_NAMEDCAPTURE)

	void transform_seqdata(state_array &piece, const posdata_holder &pos)
	{
		ui_l32 seqlen = static_cast<ui_l32>(pos.indices.size());
		state_type castate;

		castate.reset(st_character_class);
		castate.char_num = this->character_class.register_newclass(pos.ranges);

		if (seqlen > 0)
		{
			const bool has_empty = pos.has_empty();
#if !defined(SRELLDBG_NO_POS_OPT)
			bool hooked = false;
			state_size_type prevbranch_end = 0;
#else
			state_size_type prevbranch_alt = 0;
#endif
			state_type branchstate;
			state_type jumpstate;
			state_array branch;

			branch.resize(seqlen);
			for (ui_l32 i = 0; i < seqlen; ++i)
				branch[i].reset();

			branchstate.reset(st_epsilon, epsilon_type::et_alt);

			jumpstate.reset(st_epsilon, epsilon_type::et_brnchend);	//  '/'

			for (--seqlen; seqlen >= 2; --seqlen)
			{
				ui_l32 offset = pos.indices[seqlen];
				const ui_l32 seqend = pos.indices[seqlen - 1];

				if (offset != seqend)
				{
					branch.shrink(seqlen + 1);
					branch[seqlen] = jumpstate;

					for (ui_l32 count = 0; offset < seqend; ++offset)
					{
						const ui_l32 seqch = pos.seqs[offset];
						state_type *const ost = &branch[count++];

						ost->char_num = seqch & masks::cf_char;
						this->NFA_states[0].flags |= ost->flags = (seqch & masks::cfolded) ? sflags::icase : 0;

						if (count == seqlen)
						{
#if !defined(SRELLDBG_NO_POS_OPT)
							state_size_type bpos = 0;

							for (state_size_type ppos = 0; ppos < piece.size();)
							{
								if (bpos + 1 == branch.size())
								{
									piece.push_back_c(piece[ppos]);

									state_type &pst = piece[ppos];

									pst.reset(st_epsilon, epsilon_type::et_alt);
									pst.next1 = static_cast<std::ptrdiff_t>(piece.size()) - ppos - 1;
									pst.next2 = static_cast<std::ptrdiff_t>(prevbranch_end) - ppos;
									pst.flags |= sflags::hooking;
									hooked = true;

									state_type &bst = piece[piece.size() - 1];

									bst.next1 = bst.next1 - pst.next1;
									bst.next2 = bst.next2 ? (bst.next2 - pst.next1) : 0;
									bst.flags |= sflags::hookedlast;
									goto SKIP_APPEND;
								}

								state_type &pst = piece[ppos];

#if 0
								if (pst.type == st_epsilon)
									ppos += pst.next1;
								else
#endif
								if (pst.char_num == branch[bpos].char_num)
								{
									++bpos;
									ppos += pst.next1;
								}
								else if (pst.next2)
									ppos += pst.next2;
								else
								{
									pst.next2 = static_cast<std::ptrdiff_t>(piece.size()) - ppos;
									break;
								}
							}

							{
								const state_size_type alen = branch.size() - bpos;

								if (piece.size())
									piece[prevbranch_end].next1 = piece.size() + alen - 1 - prevbranch_end;

								piece.append(branch, bpos, alen);
								prevbranch_end = piece.size() - 1;
							}
							SKIP_APPEND:
							count = 0;

#else	//  defined(SRELLDBG_NO_POS_OPT)

							if (piece.size())
							{
								state_type &laststate = piece[piece.size() - 1];

								laststate.next1 = seqlen + 2;
								piece[prevbranch_alt].next2 = static_cast<std::ptrdiff_t>(piece.size()) - prevbranch_alt;
							}
							prevbranch_alt = piece.size();
							piece.push_back(branchstate);
							piece.append(branch);
							count = 0;

#endif	//  !defined(SRELLDBG_NO_POS_OPT)
						}
					}
				}
			}

			if (piece.size())
			{
#if !defined(SRELLDBG_NO_POS_OPT)
				state_type &laststate = piece[prevbranch_end];

				laststate.next1 = piece.size() + (has_empty ? 2 : 1) - prevbranch_end;

				branchstate.next2 = static_cast<std::ptrdiff_t>(piece.size()) + 1;
				piece.insert(0, branchstate);
#else
				state_type &laststate = piece[piece.size() - 1];

				laststate.next1 = has_empty ? 3 : 2;

				piece[prevbranch_alt].next2 = static_cast<std::ptrdiff_t>(piece.size()) - prevbranch_alt;
#endif
			}

			if (has_empty)
			{
				branchstate.next2 = 2;
				piece.push_back(branchstate);
			}

			piece.push_back(castate);

			branchstate.char_num = epsilon_type::et_ncgopen;
			branchstate.next1 = 1;
			branchstate.next2 = 0;
			branchstate.quantifier.set(1, 0);
			piece.insert(0, branchstate);

			branchstate.char_num = epsilon_type::et_ncgclose;
			branchstate.quantifier.atmost = 1;
			piece.push_back(branchstate);

#if !defined(SRELLDBG_NO_POS_OPT)
			if (hooked)
				reorder_piece(piece);
#endif
		}
	}

	ui_l32 translate_numbers(const ui_l32 *&curpos, const ui_l32 *const end, const ui_l32 radix, const ui_l32 minsize, const ui_l32 maxsize, const ui_l32 maxvalue) const
	{
		ui_l32 count = 0;
		ui_l32 u32value = 0;
		ui_l32 num;

		for (; maxsize == 0 || count < maxsize; ++curpos, ++count)
		{
			if (curpos == end)
				break;

			ui_l32 ch = *curpos;

			if (ch >= char_alnum::ch_0 && ch <= char_alnum::ch_9)
				num = ch - char_alnum::ch_0;
			else if (radix == 16)
			{
				ch |= masks::asc_icase;

				if (ch >= char_alnum::ch_a && ch <= char_alnum::ch_f)
					num = ch - char_alnum::ch_a + 10;
				else
					break;
			}
			else
				break;

			const ui_l32 nextvalue = u32value * radix + num;

			if (nextvalue > maxvalue || nextvalue < u32value)
				break;

			u32value = nextvalue;
		}

		if (count >= minsize)
			return u32value;

		return constants::invalid_u32value;
	}

	bool check_backreferences(cvars_type &cvars)
	{
		const state_size_type orgsize = this->NFA_states.size();
		simple_array<char> gno_found(this->number_of_brackets);
		state_array additions;

		gno_found.reset();

		for (state_size_type backrefpos = 1; backrefpos < orgsize; ++backrefpos)
		{
			state_type &brs = this->NFA_states[backrefpos];

			if (brs.type == st_roundbracket_close)
			{
				gno_found[brs.char_num] = 1;
			}
			else if (brs.type == st_backreference)
			{
				const ui_l32 &backrefno = brs.char_num;

#if !defined(SRELL_NO_NAMEDCAPTURE)
				if (brs.flags & sflags::backrefno_unresolved)
				{
					if (backrefno > cvars.unresolved_gnames.size())
						return this->set_error(regex_constants::error_backref);	//  Internal error.

					brs.flags &= ~sflags::backrefno_unresolved;

					const ui_l32 *list = this->namedcaptures[cvars.unresolved_gnames[backrefno]];

					if (list == NULL || *list < 1)
						return this->set_error(regex_constants::error_backref);

					const ui_l32 num = list[0];
					state_type newbrs(brs);

					for (ui_l32 ino = 1; ino <= num; ++ino)
					{
						if (gno_found[list[ino]])
						{
							newbrs.char_num = list[ino];
							additions.push_back(newbrs);
						}
					}

					if (additions.size() == 0)
						goto REMOVE_BACKREF;

					brs.char_num = additions[0].char_num;
					additions.erase(0);

					if (additions.size())
					{
						const std::ptrdiff_t next1abs = static_cast<std::ptrdiff_t>(backrefpos + brs.next1);
						const std::ptrdiff_t next2abs = static_cast<std::ptrdiff_t>(backrefpos + brs.next2);

						brs.next1 = static_cast<std::ptrdiff_t>(this->NFA_states.size() - backrefpos);
						brs.next2 = static_cast<std::ptrdiff_t>(this->NFA_states.size() - backrefpos);
						brs.flags |= sflags::hooking;

						const std::ptrdiff_t lastabs = static_cast<std::ptrdiff_t>(this->NFA_states.size() + additions.size() - 1);
						state_type &laststate = additions.back();

						laststate.flags |= sflags::hookedlast;
						laststate.next1 = static_cast<std::ptrdiff_t>(next1abs - lastabs);
						laststate.next2 = static_cast<std::ptrdiff_t>(next2abs - lastabs);
						this->NFA_states.append(additions);
						additions.clear();
					}
				}
				else
#endif
				{
					if (backrefno >= this->number_of_brackets)
						return this->set_error(regex_constants::error_backref);

					if (!gno_found[backrefno])
					{
						REMOVE_BACKREF:
						if (brs.next1 == -1)
						{
							state_type &prevstate = this->NFA_states[backrefpos + brs.next1];

							if (prevstate.is_asterisk_or_plus_for_onelen_atom())
							{
								brs.next1 = prevstate.farnext() + brs.next1;
								prevstate.next1 = 1;
								prevstate.next2 = 0;
								prevstate.char_num = epsilon_type::et_fmrbckrf;
							}
						}

						brs.type = st_epsilon;
						brs.next2 = 0;
						brs.char_num = epsilon_type::et_fmrbckrf;
					}
				}
			}
		}
		if (orgsize != this->NFA_states.size())
			reorder_piece(this->NFA_states);

		return true;
	}

#if !defined(SRELLDBG_NO_1STCHRCLS)

	void create_firstchar_class()
	{
		range_pairs fcc;

		const bool canbe0length = gather_nextchars(fcc, static_cast<state_size_type>(this->NFA_states[0].next1), 0u, false);

		if (canbe0length)
		{
			fcc.set_solerange(range_pair_helper(0, constants::unicode_max_codepoint));
			//  Expressions would consist of assertions only, such as /^$/.
			//  We cannot but accept every codepoint.
		}

		this->NFA_states[0].quantifier.is_greedy = this->character_class.register_newclass(fcc);

#if !defined(SRELLDBG_NO_SCFINDER) || defined(SRELL_HAS_SSE42)
		ui_l32 entrycu = constants::max_u32value;
#endif
#if defined(SRELL_HAS_SSE42)
		charT sranges[16];
		const int maxnum = sizeof (charT) ? (16 / sizeof (charT)) : 0;
		int curnum = 0;
#endif
		ui_l32 cu2 = 0;

		for (typename range_pairs::size_type i = 0; i < fcc.size(); ++i)
		{
			const range_pair &range = fcc[i];

			if (range.first > static_cast<ui_l32>(utf_traits::maxcpvalue))
				break;

			const ui_l32 maxr2 = range.second <= static_cast<ui_l32>(utf_traits::maxcpvalue) ? range.second : static_cast<ui_l32>(utf_traits::maxcpvalue);
			ui_l32 r1 = range.first;

			for (; r1 <= maxr2;)
			{
				const ui_l32 prev2 = cu2;
				const ui_l32 cu1 = utf_traits::firstcodeunit(r1) & utf_traits::bitsetmask;
				ui_l32 r2 = utf_traits::nextlengthchange(r1) - 1;

				if (r2 > maxr2)
					r2 = maxr2;

				cu2 = utf_traits::firstcodeunit(r2) & utf_traits::bitsetmask;

#if !defined(SRELLDBG_NO_BITSET)
				for (ui_l32 cu = cu1; cu <= cu2; ++cu)
					this->firstchar_class_bs.set(cu);
#endif
#if !defined(SRELLDBG_NO_SCFINDER)
				if (entrycu != constants::invalid_u32value)
				{
					if (cu1 == cu2 && (entrycu == cu1 || entrycu == constants::max_u32value))
						entrycu = cu1;
					else
						entrycu = constants::invalid_u32value;
				}
#endif
#if defined(SRELL_HAS_SSE42)
				if (curnum >= 0)
				{
					if (curnum > 0 && (prev2 == cu1 || prev2 + 1 == cu1))
					{
						sranges[curnum - 1] = static_cast<charT>(cu2);
					}
					else if (curnum < maxnum)
					{
						sranges[curnum++] = static_cast<charT>(cu1);
						sranges[curnum++] = static_cast<charT>(cu2);
					}
					else
						curnum = -1;
				}
#endif
				static_cast<void>(prev2);
				if (r2 == maxr2)
					break;

				r1 = r2 + 1;
			}
		}

		if (entrycu < constants::max_u32value)
			++entrycu;
		else
			entrycu = 0;

#if defined(SRELL_HAS_SSE42)
#if defined(SRELL_OMIT_CPUCHECK)
		if (sizeof (charT) <= 2)
#else
		if ((cpu_checker<int>::x86simd() & 1) && sizeof (charT) <= 2)
#endif
		{
			if (curnum > 0)
			{
				entrycu |= curnum << 16;	//  Bit 16 may be overlapping but safe. curnum's bit 0 is always 0.
				std::memcpy(&this->simdranges, sranges, 16);
			}
		}
#endif

#if !defined(SRELLDBG_NO_SCFINDER) || defined(SRELL_HAS_SSE42)
		this->NFA_states[0].char_num = entrycu;
#endif
	}
#endif	//  !defined(SRELLDBG_NO_1STCHRCLS)

	bool gather_nextchars(range_pairs &nextcharclass, state_size_type pos, simple_array<char> &checked, const ui_l32 bracket_number, const bool subsequent) const
	{
		bool canbe0length = false;

		for (;;)
		{
			const state_type &state = this->NFA_states[pos];

			if (checked[pos])
				break;

			checked[pos] = 1;

			if (state.next2
					&& (state.type != st_increment_counter)
					&& (state.type != st_save_and_reset_counter)
					&& (state.type != st_roundbracket_open)
					&& (state.type != st_repeat_in_push)
					&& (state.type != st_backreference || (state.next1 != state.next2))
					&& (state.type != st_lookaround_open))
				if (gather_nextchars(nextcharclass, pos + state.next2, checked, bracket_number, subsequent))
					canbe0length = true;

			switch (state.type)
			{
			case st_character:
				if (!(state.flags & sflags::icase))
				{
					nextcharclass.join(range_pair_helper(state.char_num));
				}
				else
				{
					ui_l32 table[ucf_constants::rev_maxset];
					const ui_l32 setnum = unicode_case_folding::do_caseunfolding(table, state.char_num);

					for (ui_l32 j = 0; j < setnum; ++j)
						nextcharclass.join(range_pair_helper(table[j]));
				}
				return canbe0length;

			case st_character_class:
				nextcharclass.merge(this->character_class.view(state.char_num));
				return canbe0length;

			case st_backreference:
				{
					const state_size_type nextpos = find_next1_of_bracketopen(state.char_num);

					gather_nextchars(nextcharclass, nextpos, state.char_num, subsequent);
				}
				break;

			case st_eol:
			case st_bol:
			case st_boundary:
				if (subsequent)
					nextcharclass.set_solerange(range_pair_helper(0, constants::unicode_max_codepoint));

				break;

			case st_lookaround_open:
				if (!state.flags && state.quantifier.is_greedy == 0)	//  !is_not.
				{
					gather_nextchars(nextcharclass, pos + 2, checked, 0u, subsequent);
				}
				else if (subsequent)
					nextcharclass.set_solerange(range_pair_helper(0, constants::unicode_max_codepoint));

				break;

			case st_roundbracket_close:
				if (/* bracket_number == 0 || */ state.char_num != bracket_number)
					break;
				//@fallthrough@

			case st_success:	//  == st_lookaround_close.
				return true;

			default:;
			}

			if (state.next1)
				pos += state.next1;
			else
				break;
		}
		return canbe0length;
	}

	bool gather_nextchars(range_pairs &nextcharclass, const state_size_type pos, const ui_l32 bracket_number, const bool subsequent) const
	{
		simple_array<char> checked(this->NFA_states.size());

		checked.reset();
		return gather_nextchars(nextcharclass, pos, checked, bracket_number, subsequent);
	}

	state_size_type find_next1_of_bracketopen(const ui_l32 bracketno) const
	{
		for (state_size_type no = 0; no < this->NFA_states.size(); ++no)
		{
			const state_type &state = this->NFA_states[no];

			if (state.type == st_roundbracket_open && state.char_num == bracketno)
				return no + state.next1;
		}
		return 0;
	}

	void finalise(const bool has_fcc)
	{
#if !defined(SRELLDBG_NO_CCPOS)
		this->character_class.finalise();

		if (has_fcc)
		{
			const range_pair &posinfo = this->character_class.charclasspos(this->NFA_states[0].quantifier.is_greedy);
			this->NFA_states[0].quantifier.set(posinfo.first, posinfo.second);
		}
#endif
		static_cast<void>(has_fcc);

		for (state_size_type pos = 0; pos < this->NFA_states.size(); ++pos)
		{
			state_type &state = this->NFA_states[pos];

#if !defined(SRELLDBG_NO_ASTERISK_OPT)
			if (state.next1 || state.type == st_character || state.type == st_character_class)
#else
			if (state.next1)
#endif
				state.next_state1 = &this->NFA_states[pos + state.next1];
			else
				state.next_state1 = NULL;

			if (state.next2)
				state.next_state2 = &this->NFA_states[pos + state.next2];
			else
				state.next_state2 = NULL;

#if !defined(SRELLDBG_NO_CCPOS)
			if (state.type == st_character_class || state.type == st_bol || state.type == st_eol || state.type == st_boundary)
			{
				const range_pair &posinfo = this->character_class.charclasspos(state.char_num);
				state.quantifier.set(posinfo.first, posinfo.second);
			}
#endif	//  !defined(SRELLDBG_NO_CCPOS)

			if (state.type == st_character && state.flags & sflags::icase)
				state.type = st_characteri;
		}
	}

	bool optimise(const cvars_type &cvars)
	{
		const bool needs_prefilter =
#if !defined(SRELLDBG_NO_BMH)
			 !this->bmdata &&
#endif
			 !(this->soflags & regex_constants::sticky);

#if !defined(SRELLDBG_NO_BRANCH_OPT2)
		branch_optimisation2();
#endif

#if !defined(SRELLDBG_NO_MPREWINDER)
		if (needs_prefilter)
			find_better_es(1u, cvars);
#endif

#if !defined(SRELLDBG_NO_ASTERISK_OPT)
		asterisk_optimisation();
#endif

#if !defined(SRELLDBG_NO_BRANCH_OPT)
		branch_optimisation();
#endif

#if !defined(SRELLDBG_NO_1STCHRCLS)
		if (needs_prefilter)
			create_firstchar_class();
#endif

#if !defined(SRELLDBG_NO_SKIP_EPSILON)
		skip_epsilon();
#endif

		static_cast<void>(cvars);
		return needs_prefilter;
	}

#if !defined(SRELLDBG_NO_SKIP_EPSILON)

	void skip_epsilon()
	{
		for (state_size_type pos = 0; pos < this->NFA_states.size(); ++pos)
		{
			state_type &state = this->NFA_states[pos];

			if (state.next1)
				state.next1 = static_cast<std::ptrdiff_t>(skip_nonbranch_epsilon(pos + state.next1)) - pos;

			if (state.next2)
				state.next2 = static_cast<std::ptrdiff_t>(skip_nonbranch_epsilon(pos + state.next2)) - pos;
		}
	}

	state_size_type skip_nonbranch_epsilon(state_size_type pos) const
	{
		for (;;)
		{
			const state_type &state = this->NFA_states[pos];

			if (state.type == st_epsilon && state.next2 == 0)
			{
				pos += state.next1;
				continue;
			}
			break;
		}
		return pos;
	}

#endif

#if !defined(SRELLDBG_NO_ASTERISK_OPT)

	void asterisk_optimisation()
	{
		const state_size_type orgsize = this->NFA_states.size();
#if !defined(SRELLDBG_NO_SPLITCC)
		range_pairs removed;
#endif
		range_pairs curcc;
		range_pairs nextcc;
		state_array additions;

		for (state_size_type pos = 1u; pos < orgsize; ++pos)
		{
			state_type &curstate = this->NFA_states[pos];

			if ((curstate.type == st_character || curstate.type == st_character_class) && !curstate.quantifier.is_same())
			{
				const state_size_type bpos = pos + (curstate.next1 < 0 ? curstate.next1 : (curstate.quantifier.is_question() ? -1 : 0));

				if (bpos == pos)
					continue;

				state_type &bstate = this->NFA_states[bpos];
				const state_size_type nextno = bpos + bstate.farnext();
				const re_quantifier &bq = bstate.quantifier;
				state_type orgcur(curstate);

				if (curstate.type == st_character)
				{
					curcc.set_solerange(range_pair_helper(curstate.char_num));
					if (curstate.flags & sflags::icase)
						curcc.make_caseunfoldedcharset();
				}
				else
				{
					this->character_class.copy_to(curcc, curstate.char_num);
					if (curcc.size() == 0)	//  Means [], which always makes matching fail.
						goto IS_EXCLUSIVE;
				}

				additions.clear();

				{
					nextcc.clear();
					const bool canbe0length = gather_nextchars(nextcc, nextno, 0u, true);

					if (nextcc.size())
					{
						if (!canbe0length || bq.is_greedy)
						{
#if !defined(SRELLDBG_NO_SPLITCC)
							curcc.split_ranges(removed, nextcc);

							range_pairs &kept = curcc;

							if (removed.size() == 0)	//  !curcc.is_overlap(nextcc)
								goto IS_EXCLUSIVE;

							if (curstate.type == st_character_class && kept.size())
							{
								curstate.char_num = kept.consists_of_one_character();

								if (curstate.char_num != constants::invalid_u32value)
								{
									if (curstate.char_num & masks::cfolded)
									{
										curstate.char_num ^= masks::cfolded;
										this->NFA_states[0].flags |= curstate.flags = sflags::icase;
									}
									curstate.type = st_character;
								}
								else
									curstate.char_num = this->character_class.register_newclass(kept);

								curstate.flags |= (sflags::hooking | sflags::byn2);
								curstate.next2 = static_cast<std::ptrdiff_t>(this->NFA_states.size()) - pos;

								additions.resize(2);
								state_type &n0 = additions[0];
								state_type &n1 = additions[1];

								n0.reset(st_epsilon, epsilon_type::et_ccastrsk);
								n0.quantifier = bq;
								n0.next2 = static_cast<std::ptrdiff_t>(nextno) - this->NFA_states.size();
								if (!n0.quantifier.is_greedy)
								{
									n0.next1 = n0.next2;
									n0.next2 = 1;
								}

								n1.reset(st_character_class, removed.consists_of_one_character());

								if (n1.char_num != constants::invalid_u32value)
								{
									if (n1.char_num & masks::cfolded)
									{
										n1.char_num ^= masks::cfolded;
										this->NFA_states[0].flags |= n1.flags = sflags::icase;
									}
									n1.type = st_character;
								}
								else
									n1.char_num = this->character_class.register_newclass(removed);

								n1.next1 = static_cast<std::ptrdiff_t>(bq.is_infinity() ? pos : (pos + curstate.next1)) - this->NFA_states.size() - 1;
//								n1.next2 = 0;
								n1.flags |= sflags::hookedlast;
								goto IS_EXCLUSIVE;
							}

#else	//  defined(SRELLDBG_NO_SPLITCC)

							if (!curcc.is_overlap(nextcc))
								goto IS_EXCLUSIVE;

#endif	//  !defined(SRELLDBG_NO_SPLITCC)
						}
					}
					else	//  nextcc.size() == 0
					if (!canbe0length || bq.is_greedy)
						goto IS_EXCLUSIVE;

					continue;
				}
				IS_EXCLUSIVE:

				if (bstate.type != st_check_counter)
				{
					bstate.next1 = 1;
					bstate.next2 = 0;
					bstate.char_num = epsilon_type::et_aofmrast;

					if (curstate.next1 < 0)
						curstate.next1 = 0;
				}
				else
				{
					if (bstate.quantifier.atleast != 0)
					{
						const std::ptrdiff_t addpos = static_cast<std::ptrdiff_t>(this->NFA_states.size()) + additions.size();
						const state_size_type srpos = bpos - 2;
						const state_size_type rcpos = bpos - 1;
						state_type &srstate = this->NFA_states[srpos];
						state_type &rcstate = this->NFA_states[rcpos];

						if (bstate.quantifier.atleast <= 4)
						{
							orgcur.next1 = 1;
							orgcur.next2 = 0;
							orgcur.quantifier.reset();
							additions.append(bstate.quantifier.atleast, orgcur);

							orgcur.flags |= sflags::hooking;
							orgcur.next1 = addpos - srpos;

							const std::ptrdiff_t movedsrpos = addpos + bstate.quantifier.atleast - 1;

							srstate.next1 = static_cast<std::ptrdiff_t>(bpos) - movedsrpos;
							srstate.next2 = static_cast<std::ptrdiff_t>(rcpos) - movedsrpos;
							srstate.flags |= sflags::hookedlast;
							additions.back() = srstate;

							srstate = orgcur;

							bstate.quantifier.atmost -= bstate.quantifier.atleast;
						}
						else
						{
							additions.append(this->NFA_states, bpos, 4);

							srstate.next1 = addpos - srpos;

							rcstate.flags |= (sflags::hooking | sflags::byn2 | sflags::clrn2);
							rcstate.next2 = addpos - rcpos;

							state_type &flcc = additions[additions.size() - 4];

							(flcc.quantifier.is_greedy ? flcc.next2 : flcc.next1) = static_cast<std::ptrdiff_t>(bpos) - addpos;
							flcc.quantifier.atmost = flcc.quantifier.atleast;

							orgcur.flags |= sflags::hookedlast;
							orgcur.quantifier.atmost = orgcur.quantifier.atleast;
							additions.back() = orgcur;
						}
					}
					bstate.quantifier.atleast = bstate.quantifier.atmost;

					curstate.quantifier.atmost -= curstate.quantifier.atleast;
					curstate.quantifier.atleast = 0;
				}

				if (curstate.next2 == 0)
					curstate.next2 = static_cast<std::ptrdiff_t>(nextno) - pos;

				this->NFA_states.append(additions);
			}
		}
		if (orgsize != this->NFA_states.size())
			reorder_piece(this->NFA_states);
	}

#endif	//  !defined(SRELLDBG_NO_ASTERISK_OPT)

	void reorder_piece(state_array &piece) const
	{
		u32array newpos;
		ui_l32 offset = 0;

		newpos.resize(piece.size() + 1, 0);
		newpos[piece.size()] = static_cast<ui_l32>(piece.size());

		for (ui_l32 indx = 0; indx < piece.size(); ++indx)
		{
			if (newpos[indx] == 0)
			{
				newpos[indx] = indx + offset;

				state_type &st = piece[indx];

				if (st.flags & sflags::hooking)
				{
					const std::ptrdiff_t next1or2 = (st.flags & sflags::byn2) ? (st.flags ^= sflags::byn2, st.next2) : st.next1;
					st.flags ^= sflags::hooking;

					if (st.flags & sflags::clrn2)
						st.flags ^= sflags::clrn2, st.next2 = 0;

					for (ui_l32 i = static_cast<ui_l32>(indx + next1or2); i < piece.size(); ++i)
					{
						++offset;
						newpos[i] = indx + offset;
						if (piece[i].flags & sflags::hookedlast)
						{
							piece[i].flags ^= sflags::hookedlast;
							break;
						}
					}
				}
			}
			else
				--offset;
		}

		state_array newpiece(piece.size());

		for (state_size_type indx = 0; indx < piece.size(); ++indx)
		{
			state_type &st = piece[indx];

			if (st.next1 != 0)
				st.next1 = static_cast<std::ptrdiff_t>(newpos[indx + st.next1]) - newpos[indx];

			if (st.next2 != 0)
				st.next2 = static_cast<std::ptrdiff_t>(newpos[indx + st.next2]) - newpos[indx];

			newpiece[newpos[indx]] = piece[indx];
		}
		newpiece.swap(piece);
	}

	bool check_if_backref_used(state_size_type pos, const ui_l32 number) const
	{
		for (; pos < this->NFA_states.size(); ++pos)
		{
			const state_type &state = this->NFA_states[pos];

			if (state.type == st_backreference && state.char_num == number)
				return true;
		}
		return false;
	}

#if !defined(SRELLDBG_NO_BRANCH_OPT) || !defined(SRELLDBG_NO_BRANCH_OPT2)

	state_size_type gather_if_char_or_charclass(range_pairs &charclass, state_size_type pos) const
	{
		for (;;)
		{
			const state_type &cst = this->NFA_states[pos];

			if (cst.next2 != 0)
				break;

			if (cst.type == st_character)
			{
				charclass.set_solerange(range_pair_helper(cst.char_num));
				if (cst.flags & sflags::icase)
					charclass.make_caseunfoldedcharset();
				return pos;
			}
			else if (cst.type == st_character_class)
			{
				this->character_class.copy_to(charclass, cst.char_num);
				return pos;
			}
			else if (cst.type == st_epsilon && cst.char_num != epsilon_type::et_jmpinlp && cst.char_num != epsilon_type::et_ncgclose && cst.char_num != epsilon_type::et_rvfmrcg && cst.char_num != epsilon_type::et_mfrfmrcg)
			{
				pos += cst.next1;
			}
			else
				break;
		}
		return 0;
	}
#endif	//  !defined(SRELLDBG_NO_BRANCH_OPT) || !defined(SRELLDBG_NO_BRANCH_OPT2)

#if !defined(SRELLDBG_NO_BRANCH_OPT)
	void branch_optimisation()
	{
		range_pairs nextcharclass1;

		for (state_size_type pos = 1; pos < this->NFA_states.size(); ++pos)
		{
			const state_type &state = this->NFA_states[pos];

			if (state.is_alt())
			{
				const state_size_type nextcharpos = gather_if_char_or_charclass(nextcharclass1, pos + state.next1);

				if (nextcharpos)
				{
					range_pairs nextcharclass2;
					const bool canbe0length = gather_nextchars(nextcharclass2, pos + state.next2, 0u /* bracket_number */, true);

					if (!canbe0length && !nextcharclass1.is_overlap(nextcharclass2))
					{
						state_type &branch = this->NFA_states[pos];
						state_type &next1 = this->NFA_states[nextcharpos];

						next1.next2 = pos + branch.next2 - nextcharpos;
						branch.next2 = 0;
						branch.char_num = epsilon_type::et_bo1fmrbr;
					}
				}
			}
		}
	}
#endif	//  !defined(SRELLDBG_NO_BRANCH_OPT)

#if !defined(SRELLDBG_NO_BMH)
	void setup_bmhdata()
	{
		const ui_l32 folded = this->NFA_states[0].flags & sflags::icase;
		u32array u32s;

		for (state_size_type i = 1; i < this->NFA_states.size(); ++i)
		{
			const state_type &state = this->NFA_states[i];

			if (state.is_ncgroup_open_or_close())
				continue;

			if (state.type != st_character)
				return;

			if (folded && !(state.flags & sflags::icase) && unicode_case_folding::try_casefolding(state.char_num) != constants::invalid_u32value)
				return;

			u32s.push_back_c(state.char_num);
		}

		if (u32s.size() > 1)
		{
			this->bmdata = new bmh_type;
			this->bmdata->setup(u32s, folded);
		}
	}
#endif	//  !defined(SRELLDBG_NO_BMH)

#if !defined(SRELLDBG_NO_BRANCH_OPT2)

	void branch_optimisation2()
	{
		bool hooked = false;
		range_pairs basealt1stch;
		range_pairs nextalt1stch;

		for (state_size_type pos = 1; pos < this->NFA_states.size(); ++pos)
		{
			const state_type &curstate = this->NFA_states[pos];

			if (curstate.is_alt())
			{
				state_size_type precharchainpos = pos;
				const state_size_type n1pos = gather_if_char_or_charclass(basealt1stch, pos + curstate.next1);

				if (n1pos != 0)
				{
					state_type &n1ref = this->NFA_states[n1pos];
					state_size_type n2pos = precharchainpos + curstate.next2;
					state_size_type postcharchainpos = 0;

					for (;;)
					{
						state_type &n2ref = this->NFA_states[n2pos];
						const bool n2isalt = n2ref.is_alt();
						const state_size_type next2next1poso = n2pos + (n2isalt ? n2ref.next1 : 0);
						const state_size_type next2next2pos = n2isalt ? n2pos + n2ref.next2 : 0;
						const state_size_type next2next1pos = gather_if_char_or_charclass(nextalt1stch, next2next1poso);

						if (next2next1pos != 0)
						{
							const int relation = basealt1stch.relationship(nextalt1stch);

							if (relation == 0)
							{
								state_type &prechainalt = this->NFA_states[precharchainpos];
								state_type &becomes_unused = this->NFA_states[next2next1pos];
								const state_size_type next1next1pos = n1pos + n1ref.next1;

								becomes_unused.type = st_epsilon;

								if (next2next2pos)
								{
									becomes_unused.char_num = epsilon_type::et_bo2fmrbr;	//  '2'

									if (postcharchainpos == 0)
									{
										n2ref.next1 = next1next1pos - n2pos;
										n2ref.next2 = next2next1pos - n2pos;

										n1ref.next1 = n2pos - n1pos;
										n1ref.flags |= sflags::hooking;
										n2ref.flags |= sflags::hookedlast;
										hooked = true;
									}
									else
									{
										state_type &becomes_alt = this->NFA_states[postcharchainpos];

										becomes_alt.char_num = epsilon_type::et_alt;	//  '|' <- '2'
										becomes_alt.next2 = next2next1pos - postcharchainpos;

										n2ref.next2 = 0;
										n2ref.char_num = epsilon_type::et_bo2skpd;	//  '!'
									}
									postcharchainpos = next2next1pos;
									prechainalt.next2 = next2next2pos - precharchainpos;
								}
								else
								{
									if (postcharchainpos == 0)
									{
										becomes_unused.char_num = epsilon_type::et_alt;	//  '|'
										becomes_unused.next2 = becomes_unused.next1;
										becomes_unused.next1 = next1next1pos - next2next1pos;

										n1ref.next1 = next2next1pos - n1pos;
										n1ref.flags |= sflags::hooking;
										becomes_unused.flags |= sflags::hookedlast;
										hooked = true;
									}
									else
									{
										state_type &becomes_alt = this->NFA_states[postcharchainpos];

										becomes_alt.char_num = epsilon_type::et_alt;	//  '|' <- '2'
										becomes_alt.next2 = next2next1pos + becomes_unused.next1 - postcharchainpos;

										becomes_unused.char_num = epsilon_type::et_bo2skpd;	//  '!'
									}
									prechainalt.next2 = 0;
									prechainalt.char_num = epsilon_type::et_bo2fmrbr;	//  '2'
								}
							}
							else if (relation == 1)
							{
								break;
							}
							else
								precharchainpos = n2pos;
						}
						else
						{
							//  Fix for bug210428.
							//  Original: /mm2|m|mm/
							//  1st step: /m(?:m2||m)/ <- No more optimisation can be performed. Must quit.
							//  2nd step: /mm(?:2||)/ <- BUG.
							break;
						}

						if (next2next2pos == 0)
							break;

						n2pos = next2next2pos;
					}
				}
			}
		}

		if (hooked)
			reorder_piece(this->NFA_states);
	}
#endif	//   !defined(SRELLDBG_NO_BRANCH_OPT2)

#if !defined(SRELLDBG_NO_MPREWINDER)

	bool create_rewinder(const state_size_type end, const int needs_rerun, const cvars_type &cvars)
	{
		state_array newNFAs;
		state_type rwstate;

		if (!reverse_atoms(newNFAs, this->NFA_states, 1u, end, cvars) || newNFAs.size() == 0u)
			return false;

		for (state_size_type i = 0;; ++i)
		{
			if (i == newNFAs.size())
				return false;
			if (newNFAs[i].is_character_or_class())
				break;
		}

		rwstate.reset(st_lookaround_pop, meta_char::mc_eq);
		rwstate.quantifier.atmost = 0;
		newNFAs.insert(0, rwstate);

		rwstate.type = st_lookaround_open;
		rwstate.next1 = static_cast<std::ptrdiff_t>(end + newNFAs.size() + 2) - 1;
		rwstate.next2 = 1;
		rwstate.quantifier.is_greedy = needs_rerun ? 3 : 2; //  Match point rewinder.
			//  "singing" problem: /\w+ing/ against "singing" matches
			//  the entire "singing". However, if altered into
			//  /(?<=\K\w+)ing/ it matches "sing" only. To avoid this,
			//  after rewinding is finished rerunning is needed if the
			//  reversed states contain a variable length atom.
			//  TODO: This rerunning can be avoided if the reversed atoms
			//  are an exclusive sequence, like /\d+[:,]+\d+abcd/.
		newNFAs.insert(0, rwstate);

		rwstate.type = st_lookaround_close;
		rwstate.next1 = 0;
		rwstate.next2 = 0;
		newNFAs.append(1, rwstate);

		this->NFA_states.insert(1, newNFAs);
		this->NFA_states[0].next2 = static_cast<std::ptrdiff_t>(newNFAs.size()) + 1;

		return true;
	}

	bool reverse_atoms(state_array &revNFAs, const state_array &NFAs, state_size_type cur, const state_size_type send, const cvars_type &cvars)
	{
		const state_size_type orglen = send - cur;
		state_array atomseq;
		state_array revgrp;
		state_type epsilon;

		epsilon.reset(st_epsilon, epsilon_type::et_rvfmrcg);

		revNFAs.clear();

		for (; cur < send;)
		{
			const state_type &state = NFAs[cur];

			switch (state.type)
			{
			case st_epsilon:
				if (state.next2 != 0)
				{
					if (state.char_num != epsilon_type::et_alt)
					{
						const state_size_type repbgn = cur + state.nearnext();
						state_size_type repend = cur + state.farnext();

						if (repend > send)
							repend = send;

						if (repbgn >= repend)
							return false;

						atomseq.clear();

						if (NFAs[repbgn].is_character_or_class())
						{
							atomseq.append(NFAs, cur, repend - cur);

							for (state_size_type i = 0; i < atomseq.size(); ++i)
							{
								state_type &s = atomseq[i];
								if (s.type == st_epsilon && !s.quantifier.is_greedy)
								{
									s.next2 = s.next1;
									s.next1 = 1;
									s.quantifier.is_greedy = 1;
								}
							}

							state_size_type inspos = 0;

							if (revNFAs.size())
							{
								const state_type &r0 = revNFAs[0];
								const state_type &corcc = NFAs[repbgn];

								if (r0.type == corcc.type && r0.char_num == corcc.char_num)
									++inspos;
								else if (cur)
								{
									const state_type &ps = NFAs[cur - 1];

									if (ps.type == st_epsilon && ps.char_num == epsilon_type::et_jmpinlp)
									{
										revNFAs[0] = ps;
										++inspos;
									}
								}
							}
							revNFAs.insert(inspos, atomseq);
							cur = repend;
							continue;
						}

						++cur;

						if (reverse_atoms(revgrp, NFAs, cur, repend, cvars))
						{
							cur = repend;
							revNFAs.insert(0, revgrp);
							revNFAs.insert(0, epsilon);
							continue;
						}
					}
					return false;
				}
				revNFAs.insert(0, epsilon);
				++cur;
				continue;

			case st_save_and_reset_counter:
			{
				if (cur + 5 >= send)
					return false;

				const state_size_type ccpos = cur + 2;	//  state.next1;
				const state_type &cc = NFAs[ccpos];
				const state_size_type icpos = ccpos + 1;	//  cc.nearnext();
//				const state_type &ic = NFAs[icpos];
				const state_size_type repbgn = icpos + 2;	//  ic.next1;
				state_size_type repend = ccpos + cc.farnext();

				if (repend > send)
					repend = send;

				if (repbgn >= repend)
					return false;

				atomseq.clear();

				if (NFAs[repbgn].is_character_or_class())
				{
					atomseq.append(NFAs, cur, repend - cur);

					state_type &s = atomseq[2];
					if (!s.quantifier.is_greedy)
					{
						s.next2 = s.next1;
						s.next1 = 1;
						s.quantifier.is_greedy = 1;
					}

					revNFAs.insert(0, atomseq);
					cur = repend;
					continue;
				}

				if (reverse_atoms(revgrp, NFAs, repbgn, repend, cvars))
				{
					revNFAs.insert(0, revgrp);

					for (; cur < repbgn; ++cur)
						atomseq.push_back(epsilon);

					revNFAs.insert(0, atomseq);
					cur = repend;
					continue;
				}
				return false;
			}

			case st_roundbracket_open:
				atomseq.clear();
				atomseq.push_back(epsilon);
				atomseq.push_back(epsilon);
				revNFAs.insert(0, atomseq);
				cur += 2;
				continue;

			case st_roundbracket_close:
			case st_repeat_in_push:
			case st_repeat_in_pop:
			case st_check_0_width_repeat:
				revNFAs.insert(0, epsilon);
				++cur;
				continue;

			default:;
				revNFAs.insert(0, state);
				++cur;
			}
		}
		return revNFAs.size() == orglen;
	}

	bool find_better_es(state_size_type cur, const cvars_type &cvars)
	{
		const state_array &NFAs = this->NFA_states;
		state_size_type betterpos = 0u;
		ui_l32 bp_cunum = constants::invalid_u32value;
		int needs_rerun = 0;
		int next_nr = 0;
		state_size_type end = NFAs.size();
		range_pairs nextcc;

		for (; cur < end;)
		{
			const state_type &state = NFAs[cur];
			int final = 0;

			if (state.type == st_epsilon)
			{
				if (state.next2 != 0)
				{
					if ((next_nr & 2) == 0 && state.char_num != epsilon_type::et_alt)
					{
						const state_size_type repbgn = cur + state.nearnext();

						if (NFAs[repbgn].is_character_or_class())
						{
							next_nr |= 1;
							cur += state.farnext();
							if (state.quantifier.is_greedy == 0)
								next_nr |= 2;
							continue;
						}
					}
					final = 1;
				}
				else
				{
					if (state.char_num == epsilon_type::et_jmpinlp)
					{
						const state_size_type repbgn = cur + state.next1;

						if (NFAs[repbgn].is_character_or_class())
							next_nr |= 1;
						else
							end = cur + 1 + NFAs[cur + 1].farnext();

						cur = repbgn;
					}
					else
						++cur;

					continue;
				}
			}
			else if (state.type == st_save_and_reset_counter)
			{
				const state_size_type ccpos = cur + 2;	//  state.next1;
				const state_type &cc = NFAs[ccpos];
				const state_size_type repend = ccpos + cc.farnext();
				const state_size_type icpos = ccpos + 1;	//  cc.nearnext();
//				const state_type &ic = NFAs[icpos];
				const state_size_type repbgn = icpos + 2;	//  ic.next1;

				if (NFAs[repbgn].is_character_or_class())
				{
					if (!cc.quantifier.is_same())
					{
						next_nr |= 1;
						if (next_nr & 2)
						{
							final = 1;
							goto SKIP_CCHECK;
						}
					}

					if (cc.quantifier.is_greedy == 0)
						next_nr |= 2;

					if (cc.quantifier.atleast == 0)
					{
						cur = repend;
						continue;
					}
					cur = repbgn;
					SKIP_CCHECK:;
				}
				else
				{
					if (cc.quantifier.atleast == 0)
						final = 1;
					else
					{
						end = repend;
						cur = repbgn;
						continue;
					}
				}
			}
			else if (state.type == st_roundbracket_open)
			{
				cur += state.next1;
				next_nr |= 1;
				continue;
			}
			else if (state.type == st_repeat_in_push || state.type == st_bol || state.type == st_eol || state.type == st_boundary)
			{
				cur += state.next1;
				continue;
			}
			else if (state.type == st_roundbracket_close || state.type == st_check_0_width_repeat)
			{
				++cur;
				continue;
			}
			else if (state.type == st_backreference || state.type == st_lookaround_open)
				break;

			nextcc.clear();
			const bool canbe0length = gather_nextchars(nextcc, cur, 0u, false);

			if (canbe0length)
				break;

			const ui_l32 cunum = nextcc.num_codeunits<utf_traits>();

			if (bp_cunum >= cunum)
			{
				betterpos = cur;
				bp_cunum = cunum;
				needs_rerun |= next_nr;
			}

			if (final)
				break;

			++cur;
		}

		return create_rewinder(betterpos, needs_rerun, cvars);
	}

#endif	//  !defined(SRELLDBG_NO_MPREWINDER)

public:	//  For debug.

	void print_NFA_states(const int) const;
};
//  re_compiler

	}	//  namespace re_detail

//  ... "rei_compiler.hpp"]
//  ["regex_sub_match.hpp" ...

template <class BidirectionalIterator>
class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator>
{
public:

	typedef typename std::iterator_traits<BidirectionalIterator>::value_type value_type;
	typedef typename std::iterator_traits<BidirectionalIterator>::difference_type difference_type;
	typedef BidirectionalIterator iterator;
	typedef std::basic_string<value_type> string_type;

	bool matched;

//	constexpr sub_match();	//  C++11.

	sub_match() : matched(false)
	{
	}

	difference_type length() const
	{
		return matched ? std::distance(this->first, this->second) : 0;
	}

	operator string_type() const
	{
		return matched ? string_type(this->first, this->second) : string_type();
	}

	string_type str() const
	{
		return matched ? string_type(this->first, this->second) : string_type();
	}

	int compare(const sub_match &s) const
	{
		return str().compare(s.str());
	}

	int compare(const string_type &s) const
	{
		return str().compare(s);
	}

	int compare(const value_type *const s) const
	{
		return str().compare(s);
	}

	void swap(sub_match &s)
	{
		if (this != &s)
		{
			this->std::pair<BidirectionalIterator, BidirectionalIterator>::swap(s);
			std::swap(matched, s.matched);
		}
	}

	void set_(const typename re_detail::re_submatch_type<BidirectionalIterator> &br, const BidirectionalIterator srchend)
	{
		this->matched = br.counter != 0;

		if (this->matched)
		{
			this->first = br.core.open_at;
			this->second = br.core.close_at;
		}
		else
			this->first = this->second = srchend;
	}
};

//  const reference, const reference.
template <class BiIter>
bool operator==(const sub_match<BiIter> &lhs, const sub_match<BiIter> &rhs)
{
	return lhs.compare(rhs) == 0;	//  1
}

template <class BiIter>
bool operator!=(const sub_match<BiIter> &lhs, const sub_match<BiIter> &rhs)
{
	return lhs.compare(rhs) != 0;	//  2
}

template <class BiIter>
bool operator<(const sub_match<BiIter> &lhs, const sub_match<BiIter> &rhs)
{
	return lhs.compare(rhs) < 0;	//  3
}

template <class BiIter>
bool operator<=(const sub_match<BiIter> &lhs, const sub_match<BiIter> &rhs)
{
	return lhs.compare(rhs) <= 0;	//  4
}

template <class BiIter>
bool operator>=(const sub_match<BiIter> &lhs, const sub_match<BiIter> &rhs)
{
	return lhs.compare(rhs) >= 0;	//  5
}

template <class BiIter>
bool operator>(const sub_match<BiIter> &lhs, const sub_match<BiIter> &rhs)
{
	return lhs.compare(rhs) > 0;	//  6
}

//  basic_string, const reference.
template <class BiIter, class ST, class SA>
bool operator==(
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs.compare(lhs.c_str()) == 0;	//  7
}

template <class BiIter, class ST, class SA>
bool operator!=(
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(lhs == rhs);	//  8
}

template <class BiIter, class ST, class SA>
bool operator<(
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs.compare(lhs.c_str()) > 0;	//  9
}

template <class BiIter, class ST, class SA>
bool operator>(
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs < lhs;	//  10
}

template <class BiIter, class ST, class SA>
bool operator>=(
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(lhs < rhs);	//  11
}

template <class BiIter, class ST, class SA>
bool operator<=(
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(rhs < lhs);	//  12
}

//  const reference, basic_string.
template <class BiIter, class ST, class SA>
bool operator==(
	const sub_match<BiIter> &lhs,
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &rhs
)
{
	return lhs.compare(rhs.c_str()) == 0;	//  13
}

template <class BiIter, class ST, class SA>
bool operator!=(
	const sub_match<BiIter> &lhs,
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &rhs
)
{
	return !(lhs == rhs);	//  14
}

template <class BiIter, class ST, class SA>
bool operator<(
	const sub_match<BiIter> &lhs,
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &rhs
)
{
	return lhs.compare(rhs.c_str()) < 0;	//  15
}

template <class BiIter, class ST, class SA>
bool operator>(
	const sub_match<BiIter> &lhs,
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &rhs
)
{
	return rhs < lhs;	//  16
}

template <class BiIter, class ST, class SA>
bool operator>=(
	const sub_match<BiIter> &lhs,
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &rhs
)
{
	return !(lhs < rhs);	//  17
}

template <class BiIter, class ST, class SA>
bool operator<=(
	const sub_match<BiIter> &lhs,
	const std::basic_string<typename std::iterator_traits<BiIter>::value_type, ST, SA> &rhs
)
{
	return !(rhs < lhs);	//  18
}

//  pointer, const reference.
template <class BiIter>
bool operator==(
	typename std::iterator_traits<BiIter>::value_type const *lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs.compare(lhs) == 0;	//  19
}

template <class BiIter>
bool operator!=(
	typename std::iterator_traits<BiIter>::value_type const *lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(lhs == rhs);	//  20
}

template <class BiIter>
bool operator<(
	typename std::iterator_traits<BiIter>::value_type const *lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs.compare(lhs) > 0;	//  21
}

template <class BiIter>
bool operator>(
	typename std::iterator_traits<BiIter>::value_type const *lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs < lhs;	//  22
}

template <class BiIter>
bool operator>=(
	typename std::iterator_traits<BiIter>::value_type const *lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(lhs < rhs);	//  23
}

template <class BiIter>
bool operator<=(
	typename std::iterator_traits<BiIter>::value_type const *lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(rhs < lhs);	//  24
}

//  const reference, pointer.
template <class BiIter>
bool operator==(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const *rhs
)
{
	return lhs.compare(rhs) == 0;	//  25
}

template <class BiIter>
bool operator!=(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const *rhs
)
{
	return !(lhs == rhs);	//  26
}

template <class BiIter>
bool operator<(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const *rhs
)
{
	return lhs.compare(rhs) < 0;	//  27
}

template <class BiIter>
bool operator>(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const *rhs
)
{
	return rhs < lhs;	//  28
}

template <class BiIter>
bool operator>=(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const *rhs
)
{
	return !(lhs < rhs);	//  29
}

template <class BiIter>
bool operator<=(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const *rhs
)
{
	return !(rhs < lhs);	//  30
}

//  charT, const reference.
template <class BiIter>
bool operator==(
	typename std::iterator_traits<BiIter>::value_type const &lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0;	//  31
}

template <class BiIter>
bool operator!=(
	typename std::iterator_traits<BiIter>::value_type const &lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(lhs == rhs);	//  32
}

template <class BiIter>
bool operator<(
	typename std::iterator_traits<BiIter>::value_type const &lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0;	//  33
}

template <class BiIter>
bool operator>(
	typename std::iterator_traits<BiIter>::value_type const &lhs,
	const sub_match<BiIter> &rhs
)
{
	return rhs < lhs;	//  34
}

template <class BiIter>
bool operator>=(
	typename std::iterator_traits<BiIter>::value_type const &lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(lhs < rhs);	//  35
}

template <class BiIter>
bool operator<=(
	typename std::iterator_traits<BiIter>::value_type const &lhs,
	const sub_match<BiIter> &rhs
)
{
	return !(rhs < lhs);	//  36
}

//  const reference, charT.
template <class BiIter>
bool operator==(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const &rhs
)
{
	return lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0;	//  37
}

template <class BiIter>
bool operator!=(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const &rhs
)
{
	return !(lhs == rhs);	//  38
}

template <class BiIter>
bool operator<(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const &rhs
)
{
	return lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0;	//  39
}

template <class BiIter>
bool operator>(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const &rhs
)
{
	return rhs < lhs;	//  40
}

template <class BiIter>
bool operator>=(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const &rhs
)
{
	return !(lhs < rhs);	//  41
}

template <class BiIter>
bool operator<=(
	const sub_match<BiIter> &lhs,
	typename std::iterator_traits<BiIter>::value_type const &rhs
)
{
	return !(rhs < lhs);	//  42
}

template <class charT, class ST, class BiIter>
std::basic_ostream<charT, ST> &operator<<(std::basic_ostream<charT, ST> &os, const sub_match<BiIter> &m)
{
	return (os << m.str());
}

//  ... "regex_sub_match.hpp"]
//  ["regex_match_results.hpp" ...

template <class BidirectionalIterator, class Allocator = std::allocator<sub_match<BidirectionalIterator> > >
class match_results
{
private:

	typedef std::vector<sub_match<BidirectionalIterator>, Allocator> sub_match_array_;

public:

	typedef sub_match<BidirectionalIterator> value_type;
	typedef const value_type & const_reference;
	typedef const_reference reference;
	typedef typename sub_match_array_::const_iterator const_iterator;
	typedef const_iterator iterator;
	typedef typename std::iterator_traits<BidirectionalIterator>::difference_type difference_type;
	typedef typename sub_match_array_::size_type size_type;
	typedef Allocator allocator_type;
	typedef typename std::iterator_traits<BidirectionalIterator>::value_type char_type;
	typedef std::basic_string<char_type> string_type;
	typedef typename re_detail::concon_view<char_type> contiguous_container_view;

public:

	explicit match_results(const Allocator &a = Allocator()) : ready_(0u), sub_matches_(a)
	{
	}

	match_results(const match_results &m)
	{
		operator=(m);
	}

#if defined(__cpp_rvalue_references)
	match_results(match_results &&m) SRELL_NOEXCEPT
	{
		operator=(std::move(m));
	}
#endif

	match_results &operator=(const match_results &m)
	{
		if (this != &m)
		{
//			this->sstate_ = m.sstate_;
			this->ready_ = m.ready_;
			this->sub_matches_ = m.sub_matches_;
			this->prefix_ = m.prefix_;
			this->suffix_ = m.suffix_;
			this->base_ = m.base_;
#if !defined(SRELL_NO_NAMEDCAPTURE)
			this->gnames_ = m.gnames_;
#endif
		}
		return *this;
	}

#if defined(__cpp_rvalue_references)
	match_results &operator=(match_results &&m) SRELL_NOEXCEPT
	{
		if (this != &m)
		{
//			this->sstate_ = std::move(m.sstate_);
			this->ready_ = m.ready_;
			this->sub_matches_ = std::move(m.sub_matches_);
			this->prefix_ = std::move(m.prefix_);
			this->suffix_ = std::move(m.suffix_);
			this->base_ = m.base_;
#if !defined(SRELL_NO_NAMEDCAPTURE)
			this->gnames_ = std::move(m.gnames_);
#endif
		}
		return *this;
	}
#endif

//	~match_results();

	bool ready() const
	{
		return (ready_ & 1u) ? true : false;
	}

	size_type size() const
	{
		return sub_matches_.size();
	}

	size_type max_size() const
	{
		return sub_matches_.max_size();
	}

	bool empty() const
	{
		return size() == 0;
	}

	difference_type length(const size_type sub = 0) const
	{
		return (*this)[sub].length();
	}

	difference_type position(const size_type sub = 0) const
	{
		return std::distance(base_, (*this)[sub].first);
	}

	string_type str(const size_type sub = 0) const
	{
		return (*this)[sub].str();
	}

	const_reference operator[](const size_type n) const
	{
		return n < sub_matches_.size() ? sub_matches_[n] : unmatched_;
	}

#if !defined(SRELL_NO_NAMEDCAPTURE)

	difference_type length(const string_type &sub) const
	{
		return (*this)[sub].length();
	}

	difference_type position(const string_type &sub) const
	{
		return std::distance(base_, (*this)[sub].first);
	}

	string_type str(const string_type &sub) const
	{
		return (*this)[sub].str();
	}

	const_reference operator[](const string_type &sub) const
	{
		const re_detail::ui_l32 backrefno = lookup_backref_number(sub.data(), sub.data() + sub.size());

		return backrefno != gnamemap_type::notfound ? sub_matches_[backrefno] : unmatched_;
	}

	//  In the following 4 functions, CharType is substituted for char_type.
	//  If there are overloads whose parameter is const char_type *, when
	//  the argument is the literal 0, overload resolution fails between
	//  const char_type * and size_type.

	template <typename CharType>
	difference_type length(const CharType *sub) const
	{
		return (*this)[sub].length();
	}

	template <typename CharType>
	difference_type position(const CharType *sub) const
	{
		return std::distance(base_, (*this)[sub].first);
	}

	template <typename CharType>
	string_type str(const CharType *sub) const
	{
		return (*this)[sub].str();
	}

	template <typename CharType>
	const_reference operator[](const CharType *sub) const
//		requires std::is_same_v<char_type, CharType>
	{
		const re_detail::ui_l32 backrefno = lookup_backref_number(sub, sub + std::char_traits<char_type>::length(sub));

		return backrefno != gnamemap_type::notfound ? sub_matches_[backrefno] : unmatched_;
	}

#endif	//  !defined(SRELL_NO_NAMEDCAPTURE)

	const_reference prefix() const
	{
		return prefix_;
	}

	const_reference suffix() const
	{
		return suffix_;
	}

	const_iterator begin() const
	{
		return sub_matches_.begin();
	}

	const_iterator end() const
	{
		return sub_matches_.end();
	}

	const_iterator cbegin() const
	{
		return sub_matches_.begin();
	}

	const_iterator cend() const
	{
		return sub_matches_.end();
	}

	template <class OutputIter>
	OutputIter format(
		OutputIter out,
		const char_type *fmt_first,
		const char_type *const fmt_last,
		regex_constants::match_flag_type /* flags */ = regex_constants::format_default
	) const
	{
		if (this->ready() && !this->empty())
		{
#if !defined(SRELL_NO_NAMEDCAPTURE)
			const bool no_groupnames = gnames_.size() == 0;
#endif
			const value_type &m0 = (*this)[0];

			while (fmt_first != fmt_last)
			{
				if (*fmt_first != static_cast<char_type>(re_detail::meta_char::mc_dollar))	//  '$'
				{
					*out++ = *fmt_first++;
					continue;
				}

				++fmt_first;
				if (fmt_first == fmt_last)
				{
					*out++ = re_detail::meta_char::mc_dollar;	//  '$';
				}
				else if (*fmt_first == static_cast<char_type>(re_detail::char_other::co_amp))	//  '&', $&
				{
					out = std::copy(m0.first, m0.second, out);
					++fmt_first;
				}
				else if (*fmt_first == static_cast<char_type>(re_detail::char_other::co_grav))	//  '`', $`, prefix.
				{
					out = std::copy(this->prefix().first, this->prefix().second, out);
					++fmt_first;
				}
				else if (*fmt_first == static_cast<char_type>(re_detail::char_other::co_apos))	//  '\'', $', suffix.
				{
					out = std::copy(this->suffix().first, this->suffix().second, out);
					++fmt_first;
				}
#if !defined(SRELL_NO_NAMEDCAPTURE)
				else if (*fmt_first == static_cast<char_type>(re_detail::meta_char::mc_lt) && !no_groupnames)	//  '<', $<
				{
					const char_type *const lt_pos = fmt_first;

					for (++fmt_first;; ++fmt_first)
					{
						if (fmt_first == fmt_last)
						{
							fmt_first = lt_pos;
							*out++ = re_detail::meta_char::mc_dollar;	//  '$';
							break;
						}

						if (*fmt_first == static_cast<char_type>(re_detail::meta_char::mc_gt))
						{
							const re_detail::ui_l32 backref_number = lookup_backref_number(lt_pos + 1, fmt_first);

							if (backref_number != gnamemap_type::notfound)
							{
								const value_type &mn = (*this)[backref_number];

								if (mn.matched)
									out = std::copy(mn.first, mn.second, out);
							}
							++fmt_first;
							break;
						}
					}
				}
#endif	//  !defined(SRELL_NO_NAMEDCAPTURE)
				else
				{
					const char_type *const afterdollar_pos = fmt_first;
					size_type backref_number = 0;

					if (fmt_first != fmt_last && *fmt_first >= static_cast<char_type>(re_detail::char_alnum::ch_0) && *fmt_first <= static_cast<char_type>(re_detail::char_alnum::ch_9))	//  '0'-'9'
					{
						backref_number += *fmt_first - re_detail::char_alnum::ch_0;	//  '0';

						if (++fmt_first != fmt_last && *fmt_first >= static_cast<char_type>(re_detail::char_alnum::ch_0) && *fmt_first <= static_cast<char_type>(re_detail::char_alnum::ch_9))	//  '0'-'9'
						{
							backref_number *= 10;
							backref_number += *fmt_first - re_detail::char_alnum::ch_0;	//  '0';
							++fmt_first;
						}
					}

					if (backref_number && backref_number < this->size())
					{
						const value_type &mn = (*this)[backref_number];

						if (mn.matched)
							out = std::copy(mn.first, mn.second, out);
					}
					else
					{
						*out++ = re_detail::meta_char::mc_dollar;	//  '$';

						fmt_first = afterdollar_pos;
						if (*fmt_first == static_cast<char_type>(re_detail::meta_char::mc_dollar))
							++fmt_first;
					}
				}
			}
		}
		return out;
	}

	template <class OutputIter, class ST, class SA>
	OutputIter format(
		OutputIter out,
		const std::basic_string<char_type, ST, SA> &fmt,
		regex_constants::match_flag_type flags = regex_constants::format_default
	) const
	{
		return format(out, fmt.data(), fmt.data() + fmt.size(), flags);
	}

	template <class ST, class SA>
	std::basic_string<char_type, ST, SA> format(
		const string_type &fmt,
		regex_constants::match_flag_type flags = regex_constants::format_default
	) const
	{
		std::basic_string<char_type, ST, SA> result;

		format(std::back_inserter(result), fmt, flags);
		return result;
	}

	string_type format(const char_type *fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const
	{
		string_type result;

		format(std::back_inserter(result), fmt, fmt + std::char_traits<char_type>::length(fmt), flags);
		return result;
	}

	allocator_type get_allocator() const
	{
		return allocator_type();
	}

	void swap(match_results &that)
	{
		{
			const re_detail::ui_l32 tmp(ready_);
			ready_ = that.ready_;
			that.ready_ = tmp;
		}
		sub_matches_.swap(that.sub_matches_);
		prefix_.swap(that.prefix_);
		suffix_.swap(that.suffix_);
		std::swap(base_, that.base_);
#if !defined(SRELL_NO_NAMEDCAPTURE)
		gnames_.swap(that.gnames_);
#endif
	}

	regex_constants::error_type ecode() const
	{
		return static_cast<regex_constants::error_type>(ready_ >> 1);
	}

public:	//  For internal.

	typedef match_results<BidirectionalIterator> match_results_type;
	typedef typename match_results_type::size_type match_results_size_type;
	typedef typename re_detail::re_search_state<BidirectionalIterator> search_state_type;
#if !defined(SRELL_NO_NAMEDCAPTURE)
	typedef typename re_detail::groupname_mapper<char_type> gnamemap_type;
#endif

	search_state_type sstate_;

	void clear_()
	{
		ready_ = 0u;
		sub_matches_.clear();
//		prefix_.matched = false;
//		suffix_.matched = false;
#if !defined(SRELL_NO_NAMEDCAPTURE)
		gnames_.clear();
#endif
	}

#if !defined(SRELL_NO_NAMEDCAPTURE)
	bool set_match_results_(const re_detail::ui_l32 num_of_brackets, const gnamemap_type &gnames)
#else
	bool set_match_results_(const re_detail::ui_l32 num_of_brackets)
#endif
	{
		sub_matches_.resize(num_of_brackets);

		sub_matches_[0].matched = true;

		for (re_detail::ui_l32 i = 1; i < num_of_brackets; ++i)
			sub_matches_[i].set_(sstate_.bracket[i], sstate_.srchend);

		base_ = sstate_.lblim;
		prefix_.first = sstate_.srchbegin;
		prefix_.second = sub_matches_[0].first = sstate_.curbegin;
		suffix_.first = sub_matches_[0].second = sstate_.ssc.iter;
		suffix_.second = sstate_.srchend;

		prefix_.matched = prefix_.first != prefix_.second;
		suffix_.matched = suffix_.first != suffix_.second;

#if !defined(SRELL_NO_NAMEDCAPTURE)
		gnames_ = gnames;
#endif
		ready_ = 1u;
		return true;
	}

	bool set_match_results_bmh_()
	{
		sub_matches_.resize(1);
//		value_type &m0 = sub_matches_[0];

		sub_matches_[0].matched = true;

		base_ = sstate_.lblim;
		prefix_.first = sstate_.srchbegin;
		prefix_.second = sub_matches_[0].first = sstate_.ssc.iter;
		suffix_.first = sub_matches_[0].second = sstate_.nextpos;
		suffix_.second = sstate_.srchend;

		prefix_.matched = prefix_.first != prefix_.second;
		suffix_.matched = suffix_.first != suffix_.second;

		ready_ = 1u;
		return true;
	}

	void set_prefix1_(const BidirectionalIterator pf)
	{
		prefix_.first = pf;
	}

	void update_prefix1_(const BidirectionalIterator pf)
	{
		prefix_.first = pf;
		prefix_.matched = prefix_.first != prefix_.second;
	}

	void update_prefix2_(const BidirectionalIterator ps)
	{
		prefix_.second = ps;
		prefix_.matched = prefix_.first != prefix_.second;
	}

	void update_m0_(const BidirectionalIterator mf, const BidirectionalIterator ms)
	{
		sub_matches_.resize(1);

		sub_matches_[0].first = mf;
		sub_matches_[0].second = ms;
		sub_matches_[0].matched = true;

		prefix_.first = prefix_.second = mf;
	}

	bool set_as_failed_(const re_detail::ui_l32 reason)
	{
		ready_ = reason ? (reason << 1) : 1u;
		return false;
	}

#if !defined(SRELL_NO_NAMEDCAPTURE)

	typename gnamemap_type::gname_string lookup_gname_(const re_detail::ui_l32 gno) const
	{
		return gnames_[gno];
	}

#endif

private:

#if !defined(SRELL_NO_NAMEDCAPTURE)

	re_detail::ui_l32 lookup_backref_number(const char_type *begin, const char_type *const end) const
	{
		const re_detail::ui_l32 *list = gnames_[typename gnamemap_type::view_type(begin, end - begin)];
		re_detail::ui_l32 gno = gnamemap_type::notfound;

		if (list)
		{
			const re_detail::ui_l32 num = list[0];

			for (re_detail::ui_l32 i = 1; i <= num; ++i)
			{
				gno = list[i];
				if (gno < static_cast<re_detail::ui_l32>(sub_matches_.size()) && sub_matches_[gno].matched)
					break;
			}
		}
		return gno;
	}

#endif	//  !defined(SRELL_NO_NAMEDCAPTURE)

public:	//  For debug.

	template <typename BasicRegexT>
	void print_sub_matches(const BasicRegexT &, const int) const;
	void print_addresses(const value_type &, const char *const) const;

private:

	re_detail::ui_l32 ready_;
	sub_match_array_ sub_matches_;
	value_type prefix_;
	value_type suffix_;
	value_type unmatched_;
	BidirectionalIterator base_;

#if !defined(SRELL_NO_NAMEDCAPTURE)
	gnamemap_type gnames_;
#endif
};

template <class BidirectionalIterator, class Allocator>
void swap(
	match_results<BidirectionalIterator, Allocator> &m1,
	match_results<BidirectionalIterator, Allocator> &m2
)
{
	m1.swap(m2);
}

template <class BidirectionalIterator, class Allocator>
bool operator==(
	const match_results<BidirectionalIterator, Allocator> &m1,
	const match_results<BidirectionalIterator, Allocator> &m2
)
{
	if (!m1.ready() && !m2.ready())
		return true;

	if (m1.ready() && m2.ready())
	{
		if (m1.empty() && m2.empty())
			return true;

		if (!m1.empty() && !m2.empty())
		{
			return m1.prefix() == m2.prefix() && m1.size() == m2.size() && std::equal(m1.begin(), m1.end(), m2.begin()) && m1.suffix() == m2.suffix();
		}
	}
	return false;
}

template <class BidirectionalIterator, class Allocator>
bool operator!=(
	const match_results<BidirectionalIterator, Allocator> &m1,
	const match_results<BidirectionalIterator, Allocator> &m2
)
{
	return !(m1 == m2);
}

//  ... "regex_match_results.hpp"]
//  ["rei_algorithm.hpp" ...

	namespace re_detail
	{

struct is_cont_iter { enum { is_ci = 1 }; };
struct non_cont_iter { enum { is_ci = 0 }; };

template <typename charT, typename traits>
class re_object : public re_compiler<charT, traits>
{
public:

	template <typename BidirectionalIterator, typename Allocator>
	bool search
	(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		const BidirectionalIterator lookbehind_limit,
		match_results<BidirectionalIterator, Allocator> &results,
		const regex_constants::match_flag_type flags
	) const
	{
		ui_l32 reason = 0;

		results.clear_();

		if (this->NFA_states.size())
		{
			typedef typename std::iterator_traits<BidirectionalIterator> bi_traits;
			typedef typename contiguous_checker<BidirectionalIterator, 0>::itype ci_checker;
#if defined(SRELL_HAS_SSE42)
			typedef ci_checker simd_ac;
#else
			typedef non_cont_iter simd_ac;
#endif
			re_search_state<BidirectionalIterator> &sstate = results.sstate_;

			sstate.init(begin, end, lookbehind_limit, flags | static_cast<regex_constants::match_flag_type>(this->soflags & regex_constants::sticky));

#if !defined(SRELLDBG_NO_BMH)
			if (this->bmdata && !(sstate.flags & regex_constants::match_continuous))
			{
				typedef typename bi_traits::iterator_category ic;

				if (this->NFA_states[0].flags == 0 ? this->bmdata->do_casesensitivesearch(sstate, ic()) : this->bmdata->do_icasesearch(sstate, ic()))
					return results.set_match_results_bmh_();
			}
			else
#endif	//  !defined(SRELLDBG_NO_BMH)
			{
				sstate.init2(this->number_of_brackets, this->number_of_counters, this->number_of_repeats);

				if (sstate.flags & regex_constants::match_continuous)
				{
					sstate.entry_state = this->NFA_states[0].next_state2;

					sstate.ssc.iter = sstate.nextpos;

#if defined(SRELL_NO_LIMIT_COUNTER)
					sstate.reset();
#else
					sstate.reset(this->limit_counter);
#endif
					reason = do_match<false>(sstate);
				}
				else
				{
					sstate.entry_state = this->NFA_states[0].next_state1;

#if !defined(SRELLDBG_NO_SCFINDER)
SRELL_NO_VCWARNING(4127)
					if ((this->NFA_states[0].char_num & static_cast<ui_l32>(utf_traits::ecmask))
#if defined(SRELL_HAS_SSE42)
						&& ((simd_ac::is_ci == 0) || ((cpu_checker<int>::x86simd() & 2)
#if !defined(_MSC_VER) || (((_HAS_CXX17 + 0) > 0) && (!defined(_MSVC_STL_UPDATE) || (_MSVC_STL_UPDATE < 202408L)))
							&& (sizeof (typename bi_traits::value_type) != 2)
#endif
						))
#endif
					)
SRELL_NO_VCWARNING_END
					{
						reason = do_search_sc(sstate, ci_checker());
					}
					else
#endif	//  !defined(SRELLDBG_NO_SCFINDER)
					{
						reason = do_search(sstate, simd_ac());
					}
				}

				if (reason == 1)
				{
#if !defined(SRELL_NO_NAMEDCAPTURE)
					return results.set_match_results_(this->number_of_brackets, this->namedcaptures);
#else
					return results.set_match_results_(this->number_of_brackets);
#endif
				}

#if !defined(SRELL_NO_THROW)
				if (reason && !(this->soflags & regex_constants::quiet))
					throw regex_error(static_cast<regex_constants::error_type>(reason));
#endif
			}
		}
		return results.set_as_failed_(reason);
	}

private:

	typedef typename traits::utf_traits utf_traits;

#if defined(SRELL_HAS_SSE42)

	template <typename ContiguousIterator>
	SRELL_AT_SSE42 ui_l32 do_search(re_search_state<ContiguousIterator> &sstate, const is_cont_iter) const
	{
		typedef typename std::iterator_traits<ContiguousIterator>::value_type char_type2;

SRELL_NO_VCWARNING(4127)
		if SRELL_IFCE (sizeof (charT) == sizeof (char_type2))
SRELL_NO_VCWARNING_END
		{
			const int numofranges = static_cast<int>(this->NFA_states[0].char_num >> 16) & 0x1e;

			if (numofranges)
			{
				const int borw = sizeof (char_type2) == 1 ? 4 : 5;
				const int maxsize = sizeof (char_type2) == 1 ? 16 : 8;
				const __m128i sranges = this->simdranges;

				for (; (sstate.srchend - sstate.nextpos) >= maxsize;)
				{
					__m128i data;
					std::memcpy(&data, &*sstate.nextpos, 16);
					const int pos = _mm_cmpestri(sranges, numofranges, data, maxsize, borw);

					if (pos == maxsize)
					{
						sstate.nextpos += maxsize;
						continue;
					}
					sstate.nextpos += pos;
					sstate.ssc.iter = sstate.nextpos;

SRELL_NO_VCWARNING(4127)
					if (utf_traits::maxseqlen > 1 && utf_traits::is_mculeading(*sstate.nextpos & utf_traits::bitsetmask))
SRELL_NO_VCWARNING_END
					{
						const ui_l32 cp = utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);
						const re_quantifier &r0q = this->NFA_states[0].quantifier;

#if !defined(SRELLDBG_NO_CCPOS)
						if (!this->character_class.is_included(r0q.atleast, r0q.atmost, cp))
#else
						if (!this->character_class.is_included(r0q.is_greedy, cp))
#endif
							continue;
					}
					else
						++sstate.nextpos;

#if defined(SRELL_NO_LIMIT_COUNTER)
					sstate.reset();
#else
					sstate.reset(this->limit_counter);
#endif
					const ui_l32 reason = do_match<false>(sstate);
					if (reason)
						return reason;
				}
			}
		}
		return do_search(sstate, non_cont_iter());
	}

#endif //  defined(SRELL_HAS_SSE42)

	template <typename BidirectionalIterator>
	ui_l32 do_search(re_search_state<BidirectionalIterator> &sstate, const non_cont_iter) const
	{
		for (;;)
		{
			const bool final = sstate.nextpos == sstate.srchend;

			sstate.ssc.iter = sstate.nextpos;

			if (!final)
			{
#if defined(SRELLDBG_NO_1STCHRCLS)
				utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);
#else
	#if !defined(SRELLDBG_NO_BITSET)
				const ui_l32 cu = *sstate.nextpos & utf_traits::bitsetmask;

				if (!this->firstchar_class_bs.test(cu))
				{
					++sstate.nextpos;
					continue;
				}

SRELL_NO_VCWARNING(4127)
				if (utf_traits::maxseqlen > 1 && utf_traits::is_mculeading(cu))
SRELL_NO_VCWARNING_END
				{
					const ui_l32 cp = utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);
					const re_quantifier &r0q = this->NFA_states[0].quantifier;

#if !defined(SRELLDBG_NO_CCPOS)
					if (!this->character_class.is_included(r0q.atleast, r0q.atmost, cp))
#else
					if (!this->character_class.is_included(r0q.is_greedy, cp))
#endif
						continue;
				}
				else
					++sstate.nextpos;
	#else
				const ui_l32 firstchar = utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);

				const re_quantifier &r0q = this->NFA_states[0].quantifier;

#if !defined(SRELLDBG_NO_CCPOS)
				if (!this->character_class.is_included(r0q.atleast, r0q.atmost, firstchar))
#else
				if (!this->character_class.is_included(r0q.is_greedy, firstchar))
#endif
					continue;
	#endif
#endif	//  defined(SRELLDBG_NO_1STCHRCLS)
			}
			//  Even when final == true, we have to try for such expressions
			//  as "" =~ /^$/ or "..." =~ /$/.

#if defined(SRELL_NO_LIMIT_COUNTER)
			sstate.reset(/* first */);
#else
			sstate.reset(/* first, */ this->limit_counter);
#endif
			const ui_l32 reason = do_match<false>(sstate);
			if (reason)
				return reason;

			if (final)
				break;
		}
		return 0;
	}

#if !defined(SRELLDBG_NO_SCFINDER)

	template <typename ContiguousIterator>
	ui_l32 do_search_sc(re_search_state<ContiguousIterator> &sstate, const is_cont_iter) const
	{
		typedef typename std::iterator_traits<ContiguousIterator>::value_type char_type2;
		const char_type2 ec = static_cast<char_type2>(this->NFA_states[0].char_num & static_cast<ui_l32>(utf_traits::ecmask)) - 1;
		const bool ismcul = utf_traits::is_mculeading(ec);

		static_cast<void>(ismcul);

		for (; sstate.nextpos < sstate.srchend;)
		{
			const char_type2 *const bgnpos = find_(&*sstate.nextpos, sstate.srchend - sstate.nextpos, ec);

			if (bgnpos)
			{
				sstate.nextpos += bgnpos - &*sstate.nextpos;
				sstate.ssc.iter = sstate.nextpos;

SRELL_NO_VCWARNING(4127)
				if (utf_traits::maxseqlen > 1 && ismcul)
SRELL_NO_VCWARNING_END
				{
					const ui_l32 cp = utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);
					const re_quantifier &r0q = this->NFA_states[0].quantifier;

#if !defined(SRELLDBG_NO_CCPOS)
					if (!this->character_class.is_included(r0q.atleast, r0q.atmost, cp))
#else
					if (!this->character_class.is_included(r0q.is_greedy, cp))
#endif
						continue;
				}
				else
					++sstate.nextpos;

#if defined(SRELL_NO_LIMIT_COUNTER)
				sstate.reset();
#else
				sstate.reset(this->limit_counter);
#endif
				const ui_l32 reason = do_match<false>(sstate);
				if (reason)
					return reason;
			}
			else
				break;
		}
		return 0;
	}

	template <typename BidirectionalIterator>
	ui_l32 do_search_sc(re_search_state<BidirectionalIterator> &sstate, const non_cont_iter) const
	{
		typedef typename std::iterator_traits<BidirectionalIterator>::value_type char_type2;
		const char_type2 ec = static_cast<char_type2>(this->NFA_states[0].char_num & static_cast<ui_l32>(utf_traits::ecmask)) - 1;
		const bool ismcul = utf_traits::is_mculeading(ec);

		static_cast<void>(ismcul);

		for (; sstate.nextpos != sstate.srchend;)
		{
			if ((*sstate.nextpos ^ ec) & utf_traits::bitsetmask)
			{
				++sstate.nextpos;
				continue;
			}

			sstate.ssc.iter = sstate.nextpos;

SRELL_NO_VCWARNING(4127)
			if (utf_traits::maxseqlen > 1 && ismcul)
SRELL_NO_VCWARNING_END
			{
				const ui_l32 cp = utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);
				const re_quantifier &r0q = this->NFA_states[0].quantifier;

#if !defined(SRELLDBG_NO_CCPOS)
				if (!this->character_class.is_included(r0q.atleast, r0q.atmost, cp))
#else
				if (!this->character_class.is_included(r0q.is_greedy, cp))
#endif
					continue;
			}
			else
				++sstate.nextpos;

#if defined(SRELL_NO_LIMIT_COUNTER)
			sstate.reset();
#else
			sstate.reset(this->limit_counter);
#endif
			const ui_l32 reason = do_match<false>(sstate);
			if (reason)
				return reason;
		}
		return 0;
	}

	template <typename charT2>
	const charT2 *find_(const charT2 *const ptr, const std::size_t count, const charT2 &ch) const
	{
		return std::char_traits<charT2>::find(ptr, count, ch);
	}

#if defined(__cpp_char8_t)
	const char8_t *find_(const char8_t *const ptr, const std::size_t count, const char8_t ch) const
	{
		return static_cast<const char8_t *>(std::memchr(ptr, static_cast<int>(ch), count));
	}
#endif

#endif	//  !defined(SRELLDBG_NO_SCFINDER)

	template <typename BidiIter, int N>
	struct contiguous_checker
	{
		typedef non_cont_iter itype;
	};

#if defined(__cpp_concepts)

	template <std::contiguous_iterator CI, int N>
	struct contiguous_checker<CI, N>
	{
		typedef is_cont_iter itype;
	};

#else

	template <int N>
	struct contiguous_checker<const charT *, N>
	{
		typedef is_cont_iter itype;
	};
	template <int N>
	struct contiguous_checker<typename std::basic_string<charT>::const_iterator, N>
	{
		typedef is_cont_iter itype;
	};

#endif

	template <const bool reverse, typename BidirectionalIterator>
	ui_l32 do_match(re_search_state<BidirectionalIterator> &sstate) const
	{
		typedef typename re_object_core<charT, traits>::state_type state_type;
		typedef re_search_state<BidirectionalIterator> ss_type;
//		typedef typename ss_type::search_state_core ssc_type;
		typedef typename ss_type::submatchcore_type submatchcore_type;
		typedef typename ss_type::submatch_type submatch_type;
		typedef typename ss_type::counter_type counter_type;
		typedef typename ss_type::position_type position_type;

		goto START;

		NOT_MATCHED:

#if !defined(SRELL_NO_LIMIT_COUNTER)
		if (--sstate.failure_counter)
		{
#endif
			NOT_MATCHED0:
			if (sstate.bt_size() > sstate.btstack_size)
			{
				sstate.pop_bt(sstate.ssc);

				sstate.ssc.state = sstate.ssc.state->next_state2;
			}
			else
				return 0;

#if !defined(SRELL_NO_LIMIT_COUNTER)
		}
		else
			return static_cast<ui_l32>(regex_constants::error_complexity);
#endif

		for (;;)
		{
			START:

			if (sstate.ssc.state->type <= st_characteri)
			{
				//  1 cmp 2 jmps.
				if (sstate.ssc.state->type != st_characteri)	//  st_character.
				{
SRELL_NO_VCWARNING(4127)
					if SRELL_IFCE (!reverse)
SRELL_NO_VCWARNING_END
					{
						if (!(sstate.ssc.iter == sstate.srchend))
						{
							const BidirectionalIterator prevpos = sstate.ssc.iter;
							const ui_l32 uchar = utf_traits::codepoint_inc(sstate.ssc.iter, sstate.srchend);

							for (;;)
							{
								if (sstate.ssc.state->char_num == uchar)
								{
									sstate.ssc.state = sstate.ssc.state->next_state1;
									goto START;
								}

								if (sstate.ssc.state->next_state2)
								{
									sstate.ssc.state = sstate.ssc.state->next_state2;

									if (sstate.ssc.state->type == st_character)
										continue;

									sstate.ssc.iter = prevpos;
									goto START;
								}
								break;
							}
						}
						else if (sstate.ssc.state->next_state2)
						{
							sstate.ssc.state = sstate.ssc.state->next_state2;
							continue;
						}
					}
					else	//  reverse == true.
					{
						if (!(sstate.ssc.iter == sstate.lblim))
						{
							const BidirectionalIterator prevpos = sstate.ssc.iter;
							const ui_l32 uchar = utf_traits::dec_codepoint(sstate.ssc.iter, sstate.lblim);

							for (;;)
							{
								if (sstate.ssc.state->char_num == uchar)
								{
									sstate.ssc.state = sstate.ssc.state->next_state1;
									goto START;
								}

								if (sstate.ssc.state->next_state2)
								{
									sstate.ssc.state = sstate.ssc.state->next_state2;

									if (sstate.ssc.state->type == st_character)
										continue;

									sstate.ssc.iter = prevpos;
									goto START;
								}
								break;
							}
						}
						else if (sstate.ssc.state->next_state2)
						{
							sstate.ssc.state = sstate.ssc.state->next_state2;
							continue;
						}
					}
					goto NOT_MATCHED;
				}

				//  st_characteri.
SRELL_NO_VCWARNING(4127)
				if SRELL_IFCE (!reverse)
SRELL_NO_VCWARNING_END
				{
					if (!(sstate.ssc.iter == sstate.srchend))
					{
						const BidirectionalIterator prevpos = sstate.ssc.iter;
						const ui_l32 uchar = unicode_case_folding::do_casefolding(utf_traits::codepoint_inc(sstate.ssc.iter, sstate.srchend));

						for (;;)
						{
							if (sstate.ssc.state->char_num == uchar)
							{
								sstate.ssc.state = sstate.ssc.state->next_state1;
								goto START;
							}

							if (sstate.ssc.state->next_state2)
							{
								sstate.ssc.state = sstate.ssc.state->next_state2;

								if (sstate.ssc.state->type == st_characteri)
									continue;

								sstate.ssc.iter = prevpos;
								goto START;
							}
							break;
						}
					}
					else if (sstate.ssc.state->next_state2)
					{
						sstate.ssc.state = sstate.ssc.state->next_state2;
						continue;
					}
				}
				else	//  reverse == true.
				{
					if (!(sstate.ssc.iter == sstate.lblim))
					{
						const BidirectionalIterator prevpos = sstate.ssc.iter;
						const ui_l32 uchar = unicode_case_folding::do_casefolding(utf_traits::dec_codepoint(sstate.ssc.iter, sstate.lblim));

						for (;;)
						{
							if (sstate.ssc.state->char_num == uchar)
							{
								sstate.ssc.state = sstate.ssc.state->next_state1;
								goto START;
							}

							if (sstate.ssc.state->next_state2)
							{
								sstate.ssc.state = sstate.ssc.state->next_state2;

								if (sstate.ssc.state->type == st_characteri)
									continue;

								sstate.ssc.iter = prevpos;
								goto START;
							}
							break;
						}
					}
					else if (sstate.ssc.state->next_state2)
					{
						sstate.ssc.state = sstate.ssc.state->next_state2;
						continue;
					}
				}
				goto NOT_MATCHED;
			}

			if (sstate.ssc.state->type <= st_epsilon)
			{
				//  1 cmp 2 jmps.
				if (sstate.ssc.state->type != st_epsilon)	//  st_character_class.
				{
SRELL_NO_VCWARNING(4127)
					if SRELL_IFCE (!reverse)
SRELL_NO_VCWARNING_END
					{
						if (!(sstate.ssc.iter == sstate.srchend))
						{
							const BidirectionalIterator prevpos = sstate.ssc.iter;
							const ui_l32 uchar = utf_traits::codepoint_inc(sstate.ssc.iter, sstate.srchend);

#if !defined(SRELLDBG_NO_CCPOS)
							if (this->character_class.is_included(sstate.ssc.state->quantifier.atleast, sstate.ssc.state->quantifier.atmost, uchar))
#else
							if (this->character_class.is_included(sstate.ssc.state->char_num, uchar))
#endif
							{
								sstate.ssc.state = sstate.ssc.state->next_state1;
								continue;
							}

							if (sstate.ssc.state->next_state2)
							{
								sstate.ssc.state = sstate.ssc.state->next_state2;

								sstate.ssc.iter = prevpos;
								continue;
							}
						}
						else if (sstate.ssc.state->next_state2)
						{
							sstate.ssc.state = sstate.ssc.state->next_state2;
							continue;
						}
					}
					else	//  reverse == true.
					{
						if (!(sstate.ssc.iter == sstate.lblim))
						{
							const BidirectionalIterator prevpos = sstate.ssc.iter;
							const ui_l32 uchar = utf_traits::dec_codepoint(sstate.ssc.iter, sstate.lblim);

#if !defined(SRELLDBG_NO_CCPOS)
							if (this->character_class.is_included(sstate.ssc.state->quantifier.atleast, sstate.ssc.state->quantifier.atmost, uchar))
#else
							if (this->character_class.is_included(sstate.ssc.state->char_num, uchar))
#endif
							{
								sstate.ssc.state = sstate.ssc.state->next_state1;
								continue;
							}

							if (sstate.ssc.state->next_state2)
							{
								sstate.ssc.state = sstate.ssc.state->next_state2;

								sstate.ssc.iter = prevpos;
								continue;
							}
						}
						else if (sstate.ssc.state->next_state2)
						{
							sstate.ssc.state = sstate.ssc.state->next_state2;
							continue;
						}
					}
					goto NOT_MATCHED;
				}

				//  st_epsilon.
#if defined(SRELLDBG_NO_SKIP_EPSILON)
				if (sstate.ssc.state->next_state2)
#endif
				{
					sstate.push_bt_wc(sstate.ssc);
				}

				sstate.ssc.state = sstate.ssc.state->next_state1;
				continue;
			}

			switch (sstate.ssc.state->type)
			{
			case st_check_counter:
				{
					ST_CHECK_COUNTER:
					const counter_type counter = sstate.counter[sstate.ssc.state->char_num];

					if (counter < sstate.ssc.state->quantifier.atleast)
					{
						++sstate.ssc.state;
					}
					else
					{
						if (counter < sstate.ssc.state->quantifier.atmost || sstate.ssc.state->quantifier.is_infinity())
						{
							sstate.push_bt_wc(sstate.ssc);
							sstate.ssc.state = sstate.ssc.state->next_state1;
						}
						else
						{
							sstate.ssc.state = sstate.ssc.state->quantifier.is_greedy
								? sstate.ssc.state->next_state2
								: sstate.ssc.state->next_state1;
						}
						continue;
					}
				}
				//@fallthrough@

			case st_increment_counter:
				{
					counter_type &counter = sstate.counter[sstate.ssc.state->char_num];

					if (counter != constants::infinity)
					{
						++counter;
						if (sstate.ssc.state->next_state2)
							sstate.push_bt_wc(sstate.ssc);
					}
				}
				sstate.ssc.state = sstate.ssc.state->next_state1;
				continue;

			case st_decrement_counter:
				--sstate.counter[sstate.ssc.state->char_num];
				goto NOT_MATCHED0;

			case st_save_and_reset_counter:
				{
					counter_type &counter = sstate.counter[sstate.ssc.state->char_num];

					sstate.expand(sizeof counter + sizeof sstate.ssc);

					sstate.push_c(counter);
					sstate.push_bt(sstate.ssc);
					counter = 0;
				}
				sstate.ssc.state = sstate.ssc.state->next_state1;
				goto ST_CHECK_COUNTER;

			case st_restore_counter:
				sstate.pop_c(sstate.counter[sstate.ssc.state->char_num]);
				goto NOT_MATCHED0;

			case st_roundbracket_open:
				{
					submatch_type &bracket = sstate.bracket[sstate.ssc.state->char_num];
					const re_quantifier &sq = sstate.ssc.state->quantifier;

					sstate.expand((sq.atleast <= sq.atmost ? ((sizeof (submatchcore_type) + sizeof (counter_type)) * (sq.atmost - sq.atleast + 1)) : 0) + sizeof (submatchcore_type) + sizeof sstate.ssc);

					sstate.push_sm(bracket.core);
					++bracket.counter;
						//  Now .counter is of size_t. Out-of-memory will precede its overflow.

					for (ui_l32 brno = sstate.ssc.state->quantifier.atleast; brno <= sstate.ssc.state->quantifier.atmost; ++brno)
					{
						submatch_type &inner_bracket = sstate.bracket[brno];

						sstate.push_sm(inner_bracket.core);
						sstate.push_c(inner_bracket.counter);
						inner_bracket.counter = 0;
						//  ECMAScript 2025 22.2.2.3.1, NOTE 3.
					}
					sstate.push_bt(sstate.ssc);

					(!reverse ? bracket.core.open_at : bracket.core.close_at) = sstate.ssc.iter;
				}
				sstate.ssc.state = sstate.ssc.state->next_state1;
				continue;

			case st_roundbracket_pop:
				{
					for (ui_l32 brno = sstate.ssc.state->quantifier.atmost; brno >= sstate.ssc.state->quantifier.atleast; --brno)
					{
						submatch_type &inner_bracket = sstate.bracket[brno];

						sstate.pop_c(inner_bracket.counter);
						sstate.pop_sm(inner_bracket.core);
					}

					submatch_type &bracket = sstate.bracket[sstate.ssc.state->char_num];

					--bracket.counter;
					sstate.pop_sm(bracket.core);
				}
				goto NOT_MATCHED0;

			case st_roundbracket_close:
				{
					submatch_type &bracket = sstate.bracket[sstate.ssc.state->char_num];
					submatchcore_type &brc = bracket.core;

					if ((!reverse ? brc.open_at : brc.close_at) == sstate.ssc.iter
							&& bracket.counter > sstate.ssc.state->quantifier.atleast)
						goto NOT_MATCHED0;

					sstate.ssc.state = sstate.ssc.state->next_state1;
					(!reverse ? brc.close_at : brc.open_at) = sstate.ssc.iter;
				}
				continue;

			case st_repeat_in_push:
				{
					position_type &r = sstate.repeat[sstate.ssc.state->char_num];
					const re_quantifier &sq = sstate.ssc.state->quantifier;

					sstate.expand(sizeof r + (sq.atleast <= sq.atmost ? ((sizeof (submatchcore_type) + sizeof (counter_type)) * (sq.atmost - sq.atleast + 1)) : 0) + sizeof sstate.ssc);

					sstate.push_rp(r);
					r = sstate.ssc.iter;

					for (ui_l32 brno = sstate.ssc.state->quantifier.atleast; brno <= sstate.ssc.state->quantifier.atmost; ++brno)
					{
						submatch_type &inner_bracket = sstate.bracket[brno];

						sstate.push_sm(inner_bracket.core);
						sstate.push_c(inner_bracket.counter);
						inner_bracket.counter = 0;
					}
					sstate.push_bt(sstate.ssc);
				}
				sstate.ssc.state = sstate.ssc.state->next_state1;
				continue;

			case st_repeat_in_pop:
				for (ui_l32 brno = sstate.ssc.state->quantifier.atmost; brno >= sstate.ssc.state->quantifier.atleast; --brno)
				{
					submatch_type &inner_bracket = sstate.bracket[brno];

					sstate.pop_c(inner_bracket.counter);
					sstate.pop_sm(inner_bracket.core);
				}

				sstate.pop_rp(sstate.repeat[sstate.ssc.state->char_num]);
				goto NOT_MATCHED0;

			case st_check_0_width_repeat:
				if (sstate.ssc.iter != sstate.repeat[sstate.ssc.state->char_num])
				{
					sstate.ssc.state = sstate.ssc.state->next_state1;
					continue;
				}

				if (sstate.ssc.state->next_state1->type == st_check_counter)
				{
					const counter_type counter = sstate.counter[sstate.ssc.state->next_state1->char_num];

					if (counter > sstate.ssc.state->next_state1->quantifier.atleast)
						goto NOT_MATCHED0;

					sstate.ssc.state = sstate.ssc.state->next_state1;
				}
				else
					sstate.ssc.state = sstate.ssc.state->next_state2;

				continue;

			case st_backreference:
				{
					const submatch_type &bracket = sstate.bracket[sstate.ssc.state->char_num];
					const submatchcore_type &brc = bracket.core;

					if (bracket.counter == 0 || brc.open_at == brc.close_at)	//  Undefined or "".
					{
						sstate.ssc.state = sstate.ssc.state->next_state2;
						continue;
					}

SRELL_NO_VCWARNING(4127)
					if SRELL_IFCE (!reverse)
SRELL_NO_VCWARNING_END
					{
						BidirectionalIterator backrefpos = brc.open_at;

						if (!sstate.ssc.state->flags)	//  !icase.
						{
							for (; backrefpos != brc.close_at;)
							{
								if (sstate.ssc.iter == sstate.srchend || *sstate.ssc.iter++ != *backrefpos++)
									goto NOT_MATCHED;
							}
						}
						else	//  icase.
						{
							for (; backrefpos != brc.close_at;)
							{
								if (!(sstate.ssc.iter == sstate.srchend))
								{
									const ui_l32 uchartxt = utf_traits::codepoint_inc(sstate.ssc.iter, sstate.srchend);
									const ui_l32 ucharref = utf_traits::codepoint_inc(backrefpos, brc.close_at);

									if (unicode_case_folding::do_casefolding(uchartxt) == unicode_case_folding::do_casefolding(ucharref))
										continue;
								}
								goto NOT_MATCHED;
							}
						}
					}
					else	//  reverse == true.
					{
						BidirectionalIterator backrefpos = brc.close_at;

						if (!sstate.ssc.state->flags)	//  !icase.
						{
							for (; backrefpos != brc.open_at;)
							{
								if (sstate.ssc.iter == sstate.lblim || *--sstate.ssc.iter != *--backrefpos)
									goto NOT_MATCHED;
							}
						}
						else	//  icase.
						{
							for (; backrefpos != brc.open_at;)
							{
								if (!(sstate.ssc.iter == sstate.lblim))
								{
									const ui_l32 uchartxt = utf_traits::dec_codepoint(sstate.ssc.iter, sstate.lblim);
									const ui_l32 ucharref = utf_traits::dec_codepoint(backrefpos, brc.open_at);

									if (unicode_case_folding::do_casefolding(uchartxt) == unicode_case_folding::do_casefolding(ucharref))
										continue;
								}
								goto NOT_MATCHED;
							}
						}
					}
				}
				sstate.ssc.state = sstate.ssc.state->next_state1;
				continue;

			case st_lookaround_open:
				{
					const state_type *const lostate = sstate.ssc.state;
					const re_quantifier *const losq = &lostate->quantifier;

					sstate.expand((losq->atleast <= losq->atmost ? ((sizeof (submatchcore_type) + sizeof (counter_type)) * (losq->atmost - losq->atleast + 1)) : 0) + sizeof sstate.ssc);

					for (ui_l32 brno = losq->atleast; brno <= losq->atmost; ++brno)
					{
						const submatch_type &sm = sstate.bracket[brno];
						sstate.push_sm(sm.core);
						sstate.push_c(sm.counter);
					}

					const typename ss_type::bottom_state backup_bottom(sstate.btstack_size, sstate);
					const BidirectionalIterator orgpos = sstate.ssc.iter;

					if (losq->atleast <= losq->atmost)
						sstate.push_bt(sstate.ssc);

#if !defined(SRELLDBG_NO_MPREWINDER)
					if (losq->is_greedy >= 2)
						sstate.lblim = sstate.srchbegin;
#endif

					sstate.btstack_size = sstate.bt_size();

#if defined(SRELL_FIXEDWIDTHLOOKBEHIND)
					ui_l32 is_matched;

//					if (lostate->reverse)
					{
						for (ui_l32 i = 0; i < losq->is_greedy; ++i)
						{
							if (sstate.ssc.iter == sstate.lblim)
							{
								is_matched = 0;
								goto AFTER_LOOKAROUND;
							}
							utf_traits::dec_codepoint(sstate.ssc.iter, sstate.lblim);
						}
					}
#endif
					sstate.ssc.state = lostate->next_state2->next_state1;

					//  sstate.ssc.state is no longer pointing to lookaround_open!

#if !defined(SRELL_FIXEDWIDTHLOOKBEHIND)
					const ui_l32 is_matched = (losq->is_greedy == 0 ? do_match<false>(sstate) : do_match<true>(sstate));
#else
					is_matched = do_match<false>(sstate);
#endif

					if (is_matched >> 1)
						return is_matched;

#if defined(SRELL_FIXEDWIDTHLOOKBEHIND)
					AFTER_LOOKAROUND:
#endif
					sstate.bt_resize(sstate.btstack_size);

#if !defined(SRELLDBG_NO_MPREWINDER)
					if (losq->is_greedy >= 2)
					{
						sstate.lblim = sstate.reallblim;
						if (is_matched)
							sstate.curbegin = sstate.ssc.iter;
					}
#endif

#if defined(SRELL_ENABLE_GT)
					if (lostate->char_num != meta_char::mc_gt)	//  '>'
#endif
					{
#if !defined(SRELLDBG_NO_MPREWINDER)
						if (losq->is_greedy < 3)
#endif
							sstate.ssc.iter = orgpos;
					}

					backup_bottom.restore(sstate.btstack_size, sstate);

					if (is_matched ^ lostate->flags)
					{
#if !defined(SRELLDBG_NO_MPREWINDER)
						if (losq->is_greedy == 3)
							sstate.ssc.state = this->NFA_states[0].next_state2;
						else
#endif
							sstate.ssc.state = lostate->next_state1;
						continue;
					}

					if (losq->atleast <= losq->atmost)
						sstate.pop_bt(sstate.ssc);
					sstate.ssc.state = lostate->next_state2;
				}
				//@fallthrough@

			case st_lookaround_pop:
				for (ui_l32 brno = sstate.ssc.state->quantifier.atmost; brno >= sstate.ssc.state->quantifier.atleast; --brno)
				{
					submatch_type &sm = sstate.bracket[brno];

					sstate.pop_c(sm.counter);
					sstate.pop_sm(sm.core);
				}
				goto NOT_MATCHED0;

			case st_bol:
				if (sstate.ssc.iter == sstate.lblim && !(sstate.reallblim != sstate.lblim || (sstate.flags & regex_constants::match_prev_avail) != 0))
				{
					if (!(sstate.flags & regex_constants::match_not_bol))
					{
						sstate.ssc.state = sstate.ssc.state->next_state1;
						continue;
					}
				}
					//  !sstate.is_at_lookbehindlimit() || sstate.match_prev_avail_flag()
				else if (sstate.ssc.state->flags)	//  multiline.
				{
					BidirectionalIterator lb(sstate.ssc.iter);
					const ui_l32 prevchar = utf_traits::dec_codepoint(lb, sstate.reallblim);

#if !defined(SRELLDBG_NO_CCPOS)
					if (this->character_class.is_included(sstate.ssc.state->quantifier.atleast, sstate.ssc.state->quantifier.atmost, prevchar))
#else
					if (this->character_class.is_included(re_character_class::newline, prevchar))
#endif
					{
						sstate.ssc.state = sstate.ssc.state->next_state1;
						continue;
					}
				}
				goto NOT_MATCHED;

			case st_eol:
				if (sstate.ssc.iter == sstate.srchend)
				{
					if (!(sstate.flags & regex_constants::match_not_eol))
					{
						sstate.ssc.state = sstate.ssc.state->next_state1;
						continue;
					}
				}
				else if (sstate.ssc.state->flags)	//  multiline.
				{
					BidirectionalIterator la(sstate.ssc.iter);
					const ui_l32 nextchar = utf_traits::codepoint_inc(la, sstate.srchend);

#if !defined(SRELLDBG_NO_CCPOS)
					if (this->character_class.is_included(sstate.ssc.state->quantifier.atleast, sstate.ssc.state->quantifier.atmost, nextchar))
#else
					if (this->character_class.is_included(re_character_class::newline, nextchar))
#endif
					{
						sstate.ssc.state = sstate.ssc.state->next_state1;
						continue;
					}
				}
				goto NOT_MATCHED;

			case st_boundary:	//  '\b' '\B'
				{
					ui_l32 is_matched = sstate.ssc.state->flags;	//  is_not.

					//  First, suppose the previous character is not \w but \W.

					if (sstate.ssc.iter == sstate.srchend)
					{
						if (sstate.flags & regex_constants::match_not_eow)
							is_matched ^= 1u;
					}
					else
					{
						BidirectionalIterator la(sstate.ssc.iter);
#if !defined(SRELLDBG_NO_CCPOS)
						if (this->character_class.is_included(sstate.ssc.state->quantifier.atleast, sstate.ssc.state->quantifier.atmost, utf_traits::codepoint_inc(la, sstate.srchend)))
#else
						if (this->character_class.is_included(sstate.ssc.state->char_num, utf_traits::codepoint_inc(la, sstate.srchend)))
#endif
						{
							is_matched ^= 1u;
						}
					}
					//      \W/last     \w
					//  \b  false       true
					//  \B  true        false

					//  Second, if the actual previous character is \w, flip is_matched.

					if (sstate.ssc.iter == sstate.lblim && !(sstate.reallblim != sstate.lblim || (sstate.flags & regex_constants::match_prev_avail) != 0))
					{
						if (sstate.flags & regex_constants::match_not_bow)
							is_matched ^= 1u;
					}
					else
					{
						BidirectionalIterator lb(sstate.ssc.iter);
						//  !sstate.is_at_lookbehindlimit() || sstate.match_prev_avail_flag()
#if !defined(SRELLDBG_NO_CCPOS)
						if (this->character_class.is_included(sstate.ssc.state->quantifier.atleast, sstate.ssc.state->quantifier.atmost, utf_traits::dec_codepoint(lb, sstate.reallblim)))
#else
						if (this->character_class.is_included(sstate.ssc.state->char_num, utf_traits::dec_codepoint(lb, sstate.reallblim)))
#endif
						{
							is_matched ^= 1u;
						}
					}
					//  \b                          \B
					//  pre cur \W/last \w          pre cur \W/last \w
					//  \W/base false   true        \W/base true    false
					//  \w      true    false       \w      false   true

					if (is_matched)
					{
						sstate.ssc.state = sstate.ssc.state->next_state1;
						continue;
					}

					goto NOT_MATCHED;
				}

			case st_success:	//  == lookaround_close.
				if (sstate.btstack_size)
					return 1;

				if
				(
					(!(sstate.flags & regex_constants::match_not_null) || !(sstate.ssc.iter == sstate.curbegin))
					&&
					(!(sstate.flags & regex_constants::match_match_) || sstate.ssc.iter == sstate.srchend)
				)
					return 1;

				goto NOT_MATCHED0;

#if defined(SRELLTEST_NEXTPOS_OPT)
			case st_move_nextpos:
#if !defined(SRELLDBG_NO_1STCHRCLS) && !defined(SRELLDBG_NO_BITSET)
				sstate.nextpos = sstate.ssc.iter;
				if (!(sstate.ssc.iter == sstate.srchend))
					++sstate.nextpos;
#else	//  defined(SRELLDBG_NO_1STCHRCLS) || defined(SRELLDBG_NO_BITSET)
				if (sstate.ssc.iter != sstate.curbegin)
				{
					sstate.nextpos = sstate.ssc.iter;
					if (!(sstate.ssc.iter == sstate.srchend))
						utf_traits::codepoint_inc(sstate.nextpos, sstate.srchend);
				}
#endif
				sstate.ssc.state = sstate.ssc.state->next_state1;
				continue;
#endif

			default:
				//  Reaching here means that this->NFA_states is corrupted.
				return static_cast<ui_l32>(regex_constants::error_internal);
			}
		}
	}
};
//  re_object

	}	//  namespace re_detail

//  ... "rei_algorithm.hpp"]
//  ["basic_regex.hpp" ...

template <class charT, class traits = regex_traits<charT> >
class basic_regex : public re_detail::re_object<charT, traits>
{
public:

	//  Types:
	typedef charT value_type;
	typedef traits traits_type;
	typedef typename traits::string_type string_type;
	typedef regex_constants::syntax_option_type flag_type;
	typedef typename traits::locale_type locale_type;
	typedef typename re_detail::concon_view<charT> contiguous_container_view;

	static const regex_constants::syntax_option_type icase = regex_constants::icase;
	static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
	static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
	static const regex_constants::syntax_option_type collate = regex_constants::collate;
	static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
	static const regex_constants::syntax_option_type basic = regex_constants::basic;
	static const regex_constants::syntax_option_type extended = regex_constants::extended;
	static const regex_constants::syntax_option_type awk = regex_constants::awk;
	static const regex_constants::syntax_option_type grep = regex_constants::grep;
	static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
	static const regex_constants::syntax_option_type multiline = regex_constants::multiline;

	static const regex_constants::syntax_option_type sticky = regex_constants::sticky;
	static const regex_constants::syntax_option_type dotall = regex_constants::dotall;
	static const regex_constants::syntax_option_type unicodesets = regex_constants::unicodesets;
	static const regex_constants::syntax_option_type vmode = regex_constants::vmode;
	static const regex_constants::syntax_option_type quiet = regex_constants::quiet;

	basic_regex()
	{
	}

	explicit basic_regex(const charT *const p, const flag_type f = regex_constants::ECMAScript)
	{
		assign(p, p + std::char_traits<charT>::length(p), f);
	}

	basic_regex(const charT *const p, const std::size_t len, const flag_type f = regex_constants::ECMAScript)
	{
		assign(p, p + len, f);
	}

	basic_regex(const basic_regex &e)
	{
		assign(e);
	}

#if defined(__cpp_rvalue_references)
	basic_regex(basic_regex &&e) SRELL_NOEXCEPT
	{
		assign(std::move(e));
	}
#endif

	explicit basic_regex(const contiguous_container_view c, const flag_type f = regex_constants::ECMAScript)
	{
		assign(c, f);
	}

	template <class ForwardIterator>
	basic_regex(ForwardIterator first, ForwardIterator last, const flag_type f = regex_constants::ECMAScript)
	{
		assign(first, last, f);
	}

#if defined(__cpp_initializer_lists)
	basic_regex(std::initializer_list<charT> il, const flag_type f = regex_constants::ECMAScript)
	{
		assign(il, f);
	}
#endif

//	~basic_regex();

	basic_regex &operator=(const basic_regex &right)
	{
		return assign(right);
	}

#if defined(__cpp_rvalue_references)
	basic_regex &operator=(basic_regex &&e) SRELL_NOEXCEPT
	{
		return assign(std::move(e));
	}
#endif

	basic_regex &operator=(const charT *const ptr)
	{
		return assign(ptr);
	}

#if defined(__cpp_initializer_lists)
	basic_regex &operator=(std::initializer_list<charT> il)
	{
		return assign(il.begin(), il.end());
	}
#endif

	basic_regex &operator=(const contiguous_container_view c)
	{
		return assign(c);
	}

	basic_regex &assign(const basic_regex &right)
	{
		re_detail::re_object_core<charT, traits>::operator=(right);
		return *this;
	}

#if defined(__cpp_rvalue_references)
	basic_regex &assign(basic_regex &&right) SRELL_NOEXCEPT
	{
		re_detail::re_object_core<charT, traits>::operator=(std::move(right));
		return *this;
	}
#endif

	basic_regex &assign(const charT *const ptr, const flag_type f = regex_constants::ECMAScript)
	{
		return assign(ptr, ptr + std::char_traits<charT>::length(ptr), f);
	}

	basic_regex &assign(const charT *const p, std::size_t len, const flag_type f = regex_constants::ECMAScript)
	{
		return assign(p, p + len, f);
	}

	basic_regex &assign(const contiguous_container_view c, const flag_type f = regex_constants::ECMAScript)
	{
		return assign(c.data_, c.data_ + c.size_, f);
	}

	template <class InputIterator>
	basic_regex &assign(InputIterator first, InputIterator last, const flag_type f = regex_constants::ECMAScript)
	{
#if defined(SRELL_STRICT_IMPL)
		basic_regex tmp;
		tmp.compile(first, last, f);
#if !defined(SRELL_NO_THROW)
		tmp.swap(*this);
#else
		if (tmp.ecode() == 0)
			tmp.swap(*this);
		else
		{
			this->soflags &= re_detail::masks::somask;
			this->soflags |= tmp.soflags & re_detail::masks::errmask;
		}
#endif
#else
		this->compile(first, last, f);
#endif
		return *this;
	}

#if defined(__cpp_initializer_lists)
	basic_regex &assign(std::initializer_list<charT> il, const flag_type f = regex_constants::ECMAScript)
	{
		return assign(il.begin(), il.end(), f);
	}
#endif

	unsigned mark_count() const
	{
		return this->number_of_brackets - 1;
	}

	flag_type flags() const
	{
		return static_cast<flag_type>(this->soflags & re_detail::masks::somask);
	}

	locale_type imbue(locale_type /* loc */)
	{
		return locale_type();
	}

	locale_type getloc() const
	{
		return locale_type();
	}

	void swap(basic_regex &e)
	{
		re_detail::re_object_core<charT, traits>::swap(e);
	}

	regex_constants::error_type ecode() const
	{
		return re_detail::re_object_core<charT, traits>::ecode();
	}

#if !defined(SRELL_NO_APIEXT)

	template <typename BidirectionalIterator, typename MA>
	bool match(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		match_results<BidirectionalIterator, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return base_type::search(begin, end, begin, m, flags | regex_constants::match_continuous | regex_constants::match_match_);
	}

	template <typename MA>
	bool match(
		const charT *const str,
		match_results<const charT *, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return this->match(str, str + std::char_traits<charT>::length(str), m, flags);
	}

	template <typename ST, typename SA, typename MA>
	bool match(
		const std::basic_string<charT, ST, SA> &s,
		match_results<typename std::basic_string<charT, ST, SA>::const_iterator, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return this->match(s.begin(), s.end(), m, flags);
	}
	template <typename MA>
	bool match(
		const contiguous_container_view c,
		match_results<const charT *, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return this->match(c.data_, c.data_ + c.size_, m, flags);
	}

	template <typename BidirectionalIterator, typename MA>
	bool search(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		const BidirectionalIterator lookbehind_limit,
		match_results<BidirectionalIterator, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return base_type::search(begin, end, lookbehind_limit, m, flags);
	}

	template <typename ST, typename SA, typename MA>
	bool search(
		const std::basic_string<charT, ST, SA> &s,
		const std::size_t start,
		match_results<typename std::basic_string<charT, ST, SA>::const_iterator, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return base_type::search(s.begin() + start, s.end(), s.begin(), m, flags);
	}
	template <typename MA>
	bool search(
		const contiguous_container_view c,
		const std::size_t start,
		match_results<const charT *, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return base_type::search(c.data_ + start, c.data_ + c.size_, c.data_, m, flags);
	}

	template <typename BidirectionalIterator, typename MA>
	bool search(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		match_results<BidirectionalIterator, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return base_type::search(begin, end, begin, m, flags);
	}

	template <typename MA>
	bool search(
		const charT *const str,
		match_results<const charT *, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return this->search(str, str + std::char_traits<charT>::length(str), m, flags);
	}

	template <typename ST, typename SA, typename MA>
	bool search(
		const std::basic_string<charT, ST, SA> &s,
		match_results<typename std::basic_string<charT, ST, SA>::const_iterator, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return this->search(s.begin(), s.end(), m, flags);
	}
	template <typename MA>
	bool search(
		const contiguous_container_view c,
		match_results<const charT *, MA> &m,
		const regex_constants::match_flag_type flags = regex_constants::match_default) const
	{
		return this->search(c.data_, c.data_ + c.size_, m, flags);
	}

private:

	typedef re_detail::re_object<charT, traits> base_type;

#endif	//  !defined(SRELL_NO_APIEXT)
};
#define SRELLTMP_BRFLG(fn) template <class charT, class traits> const regex_constants::syntax_option_type basic_regex<charT, traits>::fn;
SRELLTMP_BRFLG(icase)
SRELLTMP_BRFLG(nosubs)
SRELLTMP_BRFLG(optimize)
SRELLTMP_BRFLG(collate)
SRELLTMP_BRFLG(ECMAScript)
SRELLTMP_BRFLG(basic)
SRELLTMP_BRFLG(extended)
SRELLTMP_BRFLG(awk)
SRELLTMP_BRFLG(grep)
SRELLTMP_BRFLG(egrep)
SRELLTMP_BRFLG(multiline)

SRELLTMP_BRFLG(sticky)
SRELLTMP_BRFLG(dotall)
SRELLTMP_BRFLG(unicodesets)
SRELLTMP_BRFLG(vmode)
SRELLTMP_BRFLG(quiet)
#undef SRELLTMP_BRFLG

template <class charT, class traits>
void swap(basic_regex<charT, traits> &lhs, basic_regex<charT, traits> &rhs)
{
	lhs.swap(rhs);
}

//  ... "basic_regex.hpp"]
//  ["regex_iterator.hpp" ...

template <class BidirectionalIterator, class charT = typename std::iterator_traits<BidirectionalIterator>::value_type, class traits = regex_traits<charT> >
class regex_iterator
{
public:

	typedef basic_regex<charT, traits> regex_type;
	typedef match_results<BidirectionalIterator> value_type;
	typedef std::ptrdiff_t difference_type;
	typedef const value_type *pointer;
	typedef const value_type &reference;
	typedef std::forward_iterator_tag iterator_category;

	regex_iterator()
	{
		//  28.12.1.1: Constructs an end-of-sequence iterator.
	}

	regex_iterator(
		const BidirectionalIterator a,
		const BidirectionalIterator b,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
		: begin(a), end(b), pregex(&re), flags(m)
	{
		regex_search(begin, end, begin, match, *pregex, flags);
	}

	regex_iterator(const regex_iterator &that)
	{
		operator=(that);
	}

	regex_iterator &operator=(const regex_iterator &that)
	{
		if (this != &that)
		{
			this->match = that.match;
			if (this->match.size() > 0)
			{
				this->begin = that.begin;
				this->end = that.end;
				this->pregex = that.pregex;
				this->flags = that.flags;
			}
		}
		return *this;
	}

	bool operator==(const regex_iterator &right) const
	{
		if (right.match.size() == 0 || this->match.size() == 0)
			return this->match.size() == right.match.size();

		return this->begin == right.begin
			&& this->end == right.end
			&& this->pregex == right.pregex
			&& this->flags == right.flags
			&& this->match[0] == right.match[0];
	}

	bool operator!=(const regex_iterator &right) const
	{
		return !(*this == right);
	}

	const value_type &operator*() const
	{
		return match;
	}

	const value_type *operator->() const
	{
		return &match;
	}

	regex_iterator &operator++()
	{
		if (this->match.size())
		{
			BidirectionalIterator start = match[0].second;

			if (match[0].first == start)	//  The iterator holds a 0-length match.
			{
				if (start == end)
				{
					match.clear_();
				}
				else
				{
					if (!regex_search(start, end, begin, match, *pregex, flags | regex_constants::match_not_null | regex_constants::match_continuous))
					{
						const BidirectionalIterator prevend = start;

//						++start;
						utf_traits::codepoint_inc(start, end);

						flags |= regex_constants::match_prev_avail;

						if (regex_search(start, end, begin, match, *pregex, flags))
							match.update_prefix1_(prevend);
					}
				}
			}
			else
			{
				flags |= regex_constants::match_prev_avail;

				regex_search(start, end, begin, match, *pregex, flags);
			}
		}
		return *this;
	}

	regex_iterator operator++(int)
	{
		const regex_iterator tmp = *this;
		++(*this);
		return tmp;
	}

private:

	BidirectionalIterator begin;
	BidirectionalIterator end;
	const regex_type *pregex;
	regex_constants::match_flag_type flags;
	match_results<BidirectionalIterator> match;

	typedef typename traits::utf_traits utf_traits;
};

#if !defined(SRELL_NO_APIEXT)

template <typename BidirectionalIterator, typename BasicRegex = basic_regex<typename std::iterator_traits<BidirectionalIterator>::value_type, regex_traits<typename std::iterator_traits<BidirectionalIterator>::value_type> >, typename MatchResults = match_results<BidirectionalIterator> >
class regex_iterator2
{
public:

	typedef typename std::iterator_traits<BidirectionalIterator>::value_type char_type;
	typedef BasicRegex regex_type;
	typedef MatchResults value_type;
	typedef std::ptrdiff_t difference_type;
	typedef const value_type *pointer;
	typedef const value_type &reference;
	typedef std::input_iterator_tag iterator_category;
	typedef typename regex_type::contiguous_container_view contiguous_container_view;

	regex_iterator2() {}

	regex_iterator2(
		const BidirectionalIterator b,
		const BidirectionalIterator e,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(b, e, b, re, m);
	}
	regex_iterator2(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		const BidirectionalIterator lookbehind_limit,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(begin, end, lookbehind_limit, re, m);
	}

	regex_iterator2(
		const contiguous_container_view c,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(c, 0, re, m);
	}
	regex_iterator2(
		const contiguous_container_view c,
		const std::size_t start,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(c, start, re, m);
	}

	regex_iterator2(const regex_iterator2 &right)
	{
		operator=(right);
	}

	regex_iterator2 &operator=(const regex_iterator2 &right)
	{
		if (this != &right)
		{
			this->match_ = right.match_;
			if (this->match_.size() > 0)
			{
				this->begin_ = right.begin_;
				this->end_ = right.end_;
				this->pregex_ = right.pregex_;
				this->flags_ = right.flags_;
				this->submatch_ = right.submatch_;
				this->prevmatch_empty_ = right.prevmatch_empty_;
			}
		}
		return *this;
	}

	bool operator==(const regex_iterator2 &right) const
	{
		if (right.match_.size() == 0 || this->match_.size() == 0)
			return this->match_.size() == right.match_.size();

		return this->begin_ == right.begin_
			&& this->end_ == right.end_
			&& this->pregex_ == right.pregex_
			&& this->flags_ == right.flags_
			&& this->match_[0] == right.match_[0]
			&& this->submatch_ == right.submatch_
			&& this->prevmatch_empty_ == right.prevmatch_empty_;
	}

	bool operator!=(const regex_iterator2 &right) const
	{
		return !operator==(right);
	}

	const value_type &operator*() const
	{
		return match_;
	}

	const value_type *operator->() const
	{
		return &match_;
	}

	bool done() const
	{
		return match_.size() == 0;
	}

	void assign(
		const BidirectionalIterator b,
		const BidirectionalIterator e,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(b, e, b, re, m);
	}
	void assign(
		const BidirectionalIterator begin,
		const BidirectionalIterator end,
		const BidirectionalIterator lookbehind_limit,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		begin_ = lookbehind_limit;
		end_ = end;
		pregex_ = &re;
		flags_ = m;
		submatch_ = 0u;

		if (re.search(begin, end_, begin_, match_, flags_))
		{
			prevmatch_empty_ = match_[0].first == match_[0].second;
		}
		else
			match_.set_prefix1_(begin_);
	}

	void assign(
		const contiguous_container_view c,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(c, 0, re, m);
	}
	void assign(
		const contiguous_container_view c,
		const std::size_t start,
		const regex_type &re,
		const regex_constants::match_flag_type m = regex_constants::match_default)
	{
		assign(pos0_(c, BidirectionalIterator()) + start, pos1_(c, BidirectionalIterator()), pos0_(c, BidirectionalIterator()), re, m);
	}
	void assign(const regex_iterator2 &right)
	{
		operator=(right);
	}

	regex_iterator2 &operator++()
	{
		if (match_.size())
		{
			const BidirectionalIterator prevend = match_[0].second;
			BidirectionalIterator start = prevend;

			if (prevmatch_empty_)
			{
				if (start == end_)
				{
					match_.clear_();
					return *this;
				}
				utf_traits::codepoint_inc(start, end_);
			}

			if (pregex_->search(start, end_, begin_, match_, flags_ | regex_constants::match_prev_avail))
				prevmatch_empty_ = match_[0].first == match_[0].second;

			match_.update_prefix1_(prevend);
		}
		return *this;
	}

	regex_iterator2 operator++(int)
	{
		const regex_iterator2 tmp = *this;
		++(*this);
		return tmp;
	}

	//  For replace.

	//  Replaces [match_[0].first, match_[0].second) in
	//  [entire_string.begin(), entire_string.end()) with replacement,
	//  and adjusts all the internal iterators accordingly.
	template <typename ST, typename SA>
	void replace(std::basic_string<char_type, ST, SA> &entire_string, const contiguous_container_view replacement)
	{
		replace(entire_string, replacement.data_, replacement.size_);
	}

	template <typename ST, typename SA>
	void replace(std::basic_string<char_type, ST, SA> &entire_string, const char_type *const replacement, const std::size_t replen)
	{
		typedef std::basic_string<char_type, ST, SA> string_type;
		typedef typename string_type::size_type size_type;

		if (match_.size())
		{
			const BidirectionalIterator oldbegin = pos0_(entire_string, BidirectionalIterator());
			const size_type oldbeginoffset = begin_ - oldbegin;
			const size_type oldendoffset = end_ - oldbegin;
			const size_type pos = match_[0].first - oldbegin;
			const size_type count = match_[0].second - match_[0].first;
			const typename match_type::difference_type addition = replen - match_.length(0);

			entire_string.replace(pos, count, replacement, replen);

			const BidirectionalIterator newbegin = pos0_(entire_string, BidirectionalIterator());

			begin_ = newbegin + oldbeginoffset;
			end_ = newbegin + (oldendoffset + addition);	//  VC checks if an iterator exceeds end().

			match_.update_m0_(newbegin + pos, newbegin + (pos + count + addition));

			prevmatch_empty_ = count == 0;
		}
	}

	template <typename ST, typename SA>
	void replace(std::basic_string<char_type, ST, SA> &entire_string, const BidirectionalIterator b, const BidirectionalIterator e)
	{
		typedef std::basic_string<char_type, ST, SA> string_type;

		replace(entire_string, string_type(b, e));
	}

	template <typename ST, typename SA>
	void replace(std::basic_string<char_type, ST, SA> &entire_string, const char_type *const replacement)
	{
		replace(entire_string, replacement, std::char_traits<char_type>::length(replacement));
	}

	//  For split.

	//  1. Until done() returns true, gather this->prefix() and
	//     increment while split_ready() returns true,
	//  2. Once done() becomes true, get remainder().

	//  Returns if this->prefix() holds a range that is worthy of being
	//  treated as a split substring.
	bool split_ready()	//const
	{
		if (match_.size())
		{
			if (match_[0].first != end_)
				return match_.prefix().first != match_[0].second;

			//  [end_, end_) is not appropriate as a split range. Invalidates the current match.
			match_.clear_();
		}
		return false;	//  Iterating complete.
	}

	//  If only_after_match is false, returns [prefix().first, end);
	//  otherwise (if true) returns [match_[0].second, end).
	//  This function is intended to be called after iterating is
	//  finished, to receive the range of suffix() of the last match.
	//  If iterating is broken off during processing (e.g. pushing to a
	//  list container) captured subsequences (match_[n] where n >= 1),
	//  then should be called with only_after_match being true,
	//  otherwise [prefix().first, prefix().second) would be duplicated.
	const typename value_type::value_type &remainder(const bool only_after_match = false)
	{
		if (only_after_match && match_.size())
			match_.set_prefix1_(match_[0].second);

		match_.update_prefix2_(end_);
		return match_.prefix();
	}

	//  The following 4 split_* functions are intended to be used
	//  together, as follows:
	//
	//    for (it.split_begin(); !it.done(); it.split_next()) {
	//      if (++count == LIMIT)
	//        break;
	//      list.push_back(it.split_range());
	//    }
	//    list.push_back(it.split_remainder());

	//  Moves to a first subsequence for which split_ready() returns
	//  true. This should be called only once before beginning iterating.
	bool split_begin()
	{
		if (split_ready())
			return true;

		operator++();
		return split_ready();
	}

	//  Moves to a next subsequence for which split_ready() returns
	//  true.
	//  This function is intended to be used instead of the ordinary
	//  increment operator++().
	bool split_next()
	{
		if (++submatch_ >= match_.size())
		{
			submatch_ = 0u;
			operator++();
			return split_begin();
		}
		return !done();
	}

	//  Returns the current subsequence to which the iterator points.
	const typename value_type::value_type &split_range() const
	{
		return submatch_ == 0u ? match_.prefix() : match_[submatch_];
	}

	//  Returns the final subsequence immediately following the last
	//  match range. This should be called after iterating is complete
	//  or broken off.
	//  Unlike remainder() above, a boolean value corresponding to
	//  only_after_match is automatically calculated.
	const typename value_type::value_type &split_remainder()
	{
		if (submatch_ > 0u)
			match_.set_prefix1_(match_[0].second);

		match_.update_prefix2_(end_);
		return match_.prefix();
	}

	//  Returns an appropriate range depending on done().
	const typename value_type::value_type &split_aptrange()
	{
		return !done() ? split_range() : split_remainder();
	}

private:

	typedef match_results<BidirectionalIterator> match_type;
	typedef typename regex_type::traits_type::utf_traits utf_traits;

	template <typename StringLike, typename iteratorTag>
	iteratorTag pos0_(const StringLike &s, iteratorTag)
	{
		return s.begin();
	}
	template <typename StringLike>
	const char_type *pos0_(const StringLike &s, const char_type *)
	{
		return s.data();
	}

	template <typename StringLike, typename iteratorTag>
	iteratorTag pos1_(const StringLike &s, iteratorTag)
	{
		return s.end();
	}
	template <typename StringLike>
	const char_type *pos1_(const StringLike &s, const char_type *)
	{
		return s.data() + s.size();
	}

	BidirectionalIterator begin_;
	BidirectionalIterator end_;
	const regex_type *pregex_;
	regex_constants::match_flag_type flags_;
	match_type match_;
	typename match_type::size_type submatch_;
	bool prevmatch_empty_;
};

#endif	//  !defined(SRELL_NO_APIEXT)

//  ... "regex_iterator.hpp"]
//  ["regex_algorithm.hpp" ...

template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_match(
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	match_results<BidirectionalIterator, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return e.search(first, last, first, m, flags | regex_constants::match_continuous | regex_constants::match_match_);
}

template <class BidirectionalIterator, class charT, class traits>
bool regex_match(
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	match_results<BidirectionalIterator> what;

	return regex_match(first, last, what, e, flags);
}

template <class charT, class Allocator, class traits>
bool regex_match(
	const charT *const str,
	match_results<const charT *, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_match(str, str + std::char_traits<charT>::length(str), m, e, flags);
}

template <class charT, class traits>
bool regex_match(
	const charT *const str,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_match(str, str + std::char_traits<charT>::length(str), e, flags);
}

template <class ST, class SA, class Allocator, class charT, class traits>
bool regex_match(
	const std::basic_string<charT, ST, SA> &s,
	match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_match(s.begin(), s.end(), m, e, flags);
}

template <class ST, class SA, class charT, class traits>
bool regex_match(
	const std::basic_string<charT, ST, SA> &s,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_match(s.begin(), s.end(), e, flags);
}

template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	const BidirectionalIterator lookbehind_limit,
	match_results<BidirectionalIterator, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return e.search(first, last, lookbehind_limit, m, flags);
}

template <class BidirectionalIterator, class charT, class traits>
bool regex_search(
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	const BidirectionalIterator lookbehind_limit,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	match_results<BidirectionalIterator> what;
	return regex_search(first, last, lookbehind_limit, what, e, flags);
}

template <class ST, class SA, class Allocator, class charT, class traits>
bool regex_search(
	const std::basic_string<charT, ST, SA> &s,
	const std::size_t start,
	match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return e.search(s.begin() + start, s.end(), s.begin(), m, flags);
}

template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	match_results<BidirectionalIterator, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return e.search(first, last, first, m, flags);
}

template <class BidirectionalIterator, class charT, class traits>
bool regex_search(
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	match_results<BidirectionalIterator> what;
	return regex_search(first, last, what, e, flags);
}

template <class charT, class Allocator, class traits>
bool regex_search(
	const charT *const str,
	match_results<const charT *, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_search(str, str + std::char_traits<charT>::length(str), m, e, flags);
}

template <class charT, class traits>
bool regex_search(
	const charT *const str,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_search(str, str + std::char_traits<charT>::length(str), e, flags);
}

template <class ST, class SA, class Allocator, class charT, class traits>
bool regex_search(
	const std::basic_string<charT, ST, SA> &s,
	match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator> &m,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_search(s.begin(), s.end(), m, e, flags);
}

template <class ST, class SA, class charT, class traits>
bool regex_search(
	const std::basic_string<charT, ST, SA> &s,
	const basic_regex<charT, traits> &e,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	return regex_search(s.begin(), s.end(), e, flags);
}

template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class ST, class SA>
OutputIterator regex_replace(
	OutputIterator out,
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	const basic_regex<charT, traits> &e,
	const std::basic_string<charT, ST, SA> &fmt,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	typedef regex_iterator<BidirectionalIterator, charT, traits> iterator_type;

	const bool do_copy = !(flags & regex_constants::format_no_copy);
	const iterator_type eos;
	iterator_type i(first, last, e, flags);
	typename iterator_type::value_type::value_type last_m_suffix;

	last_m_suffix.first = first;
	last_m_suffix.second = last;

	for (; i != eos; ++i)
	{
		if (do_copy)
			out = std::copy(i->prefix().first, i->prefix().second, out);

		out = i->format(out, fmt, flags);
		last_m_suffix = i->suffix();

		if (flags & regex_constants::format_first_only)
			break;
	}

	if (do_copy)
		out = std::copy(last_m_suffix.first, last_m_suffix.second, out);

	return out;
}

template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
OutputIterator regex_replace(
	OutputIterator out,
	const BidirectionalIterator first,
	const BidirectionalIterator last,
	const basic_regex<charT, traits> &e,
	const charT *const fmt,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	const std::basic_string<charT> fs(fmt, fmt + std::char_traits<charT>::length(fmt));

	return regex_replace(out, first, last, e, fs, flags);
}

template <class traits, class charT, class ST, class SA, class FST, class FSA>
std::basic_string<charT, ST, SA> regex_replace(
	const std::basic_string<charT, ST, SA> &s,
	const basic_regex<charT, traits> &e,
	const std::basic_string<charT, FST, FSA> &fmt,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	std::basic_string<charT, ST, SA> result;

	regex_replace(std::back_inserter(result), s.begin(), s.end(), e, fmt, flags);
	return result;
}

template <class traits, class charT, class ST, class SA>
std::basic_string<charT, ST, SA> regex_replace(
	const std::basic_string<charT, ST, SA> &s,
	const basic_regex<charT, traits> &e,
	const charT *const fmt,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	std::basic_string<charT, ST, SA> result;

	regex_replace(std::back_inserter(result), s.begin(), s.end(), e, fmt, flags);
	return result;
}

template <class traits, class charT, class ST, class SA>
std::basic_string<charT> regex_replace(
	const charT *const s,
	const basic_regex<charT, traits> &e,
	const std::basic_string<charT, ST, SA> &fmt,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	std::basic_string<charT> result;

	regex_replace(std::back_inserter(result), s, s + std::char_traits<charT>::length(s), e, fmt, flags);
	return result;
}

template <class traits, class charT>
std::basic_string<charT> regex_replace(
	const charT *const s,
	const basic_regex<charT, traits> &e,
	const charT *const fmt,
	const regex_constants::match_flag_type flags = regex_constants::match_default)
{
	std::basic_string<charT> result;

	regex_replace(std::back_inserter(result), s, s + std::char_traits<charT>::length(s), e, fmt, flags);
	return result;
}

//  ... "regex_algorithm.hpp"]
//  ["regex_token_iterator.hpp" ...

template <class BidirectionalIterator, class charT = typename std::iterator_traits<BidirectionalIterator>::value_type, class traits = regex_traits<charT> >
class regex_token_iterator
{
public:

	typedef basic_regex<charT, traits> regex_type;
	typedef sub_match<BidirectionalIterator> value_type;
	typedef std::ptrdiff_t difference_type;
	typedef const value_type *pointer;
	typedef const value_type &reference;
	typedef std::forward_iterator_tag iterator_category;

	regex_token_iterator() : result_(NULL)
	{
		//  Constructs the end-of-sequence iterator.
	}

	regex_token_iterator(
		const BidirectionalIterator a,
		const BidirectionalIterator b,
		const regex_type &re,
		const int submatch = 0,
		regex_constants::match_flag_type m = regex_constants::match_default
	) : position_(a, b, re, m), result_(NULL), subs_(2)
	{
		post_constructor_(a, b, &submatch, 1);
	}

	regex_token_iterator(
		const BidirectionalIterator a,
		const BidirectionalIterator b,
		const regex_type &re,
		const std::vector<int> &submatches,
		regex_constants::match_flag_type m = regex_constants::match_default
	) : position_(a, b, re, m), result_(NULL), subs_(submatches.size() + 1)
	{
		post_constructor_(a, b, submatches.begin(), submatches.size());
	}

#if defined(__cpp_initializer_lists)
	regex_token_iterator(
		const BidirectionalIterator a,
		const BidirectionalIterator b,
		const regex_type &re,
		const std::initializer_list<int> submatches,
		regex_constants::match_flag_type m = regex_constants::match_default
	) : position_(a, b, re, m), result_(NULL), subs_(submatches.size() + 1)
	{
		post_constructor_(a, b, submatches.begin(), submatches.size());
	}
#endif

	template <std::size_t N>	//  Was R in TR1.
	regex_token_iterator(
		const BidirectionalIterator a,
		const BidirectionalIterator b,
		const regex_type &re,
		const int (&submatches)[N],
		regex_constants::match_flag_type m = regex_constants::match_default
	) : position_(a, b, re, m), result_(NULL), subs_(N + 1)
	{
		post_constructor_(a, b, submatches, N);
	}

	regex_token_iterator(const regex_token_iterator &that)
	{
		operator=(that);
	}

	regex_token_iterator &operator=(const regex_token_iterator &that)
	{
		if (this != &that)
		{
			this->result_ = that.result_;
			if (this->result_)
			{
				this->position_ = that.position_;
				this->suffix_ = that.suffix_;
				this->N_ = that.N_;
				this->subs_ = that.subs_;

				if (that.result_ == &that.suffix_)
					result_ = &suffix_;
				else
					result_ = subs_[this->N_] != -1 ? &((*position_)[subs_[this->N_]]) : &((*position_).prefix());
			}
		}
		return *this;
	}

	bool operator==(const regex_token_iterator &right) const
	{
		if (right.result_ == NULL || this->result_ == NULL)
			return this->result_ == right.result_;

		if (this->result_ == &this->suffix_ || right.result_ == &right.suffix_)
			return this->suffix_ == right.suffix_;

		return this->position_ == right.position_
			&& this->N_ == right.N_
			&& this->subs_ == right.subs_;
	}

	bool operator!=(const regex_token_iterator &right) const
	{
		return !(*this == right);
	}

	const value_type &operator*() const
	{
		return *result_;
	}

	const value_type *operator->() const
	{
		return result_;
	}

	regex_token_iterator &operator++()
	{
		if (result_ == &suffix_)
			result_ = NULL;
		else if (result_ != NULL)
		{
			if (++this->N_ >= subs_.size())
			{
				this->N_ = 1;
				suffix_ = position_->suffix();
				if ((++position_)->size() == 0)
				{
					result_ = (suffix_.matched && subs_[0] == -1) ? &suffix_ : NULL;
					return *this;
				}
			}
			result_ = subs_[this->N_] != -1 ? &((*position_)[subs_[this->N_]]) : &((*position_).prefix());
		}
		return *this;
	}

	regex_token_iterator operator++(int)
	{
		const regex_token_iterator tmp(*this);
		++(*this);
		return tmp;
	}

	regex_constants::error_type ecode() const
	{
		return position_->ecode();
	}

private:

	template <typename Iterator>
	void post_constructor_(const BidirectionalIterator a, const BidirectionalIterator b, Iterator it, const std::size_t num)
	{
		this->N_ = 1;

		subs_[0] = 0;
		for (std::size_t i = 0; i < num; ++i, ++it)
		{
			this->subs_[i + 1] = *it;
			if (*it == -1)
				subs_[0] = -1;
		}

		if (position_->size() && this->N_ < subs_.size())
		{
			result_ = subs_[this->N_] != -1 ? &((*position_)[subs_[this->N_]]) : &((*position_).prefix());
			return;
		}

		if (subs_[0] == -1)
		{
			suffix_.matched = a != b;

			if (suffix_.matched)
			{
				suffix_.first = a;
				suffix_.second = b;
				result_ = &suffix_;
				return;
			}
		}
		result_ = NULL;
	}

private:

	typedef regex_iterator<BidirectionalIterator, charT, traits> position_iterator;
	position_iterator position_;
	const value_type *result_;
	value_type suffix_;
	std::size_t N_;
	re_detail::simple_array<int> subs_;
};

//  ... "regex_token_iterator.hpp"]

typedef sub_match<const char *> csub_match;
typedef sub_match<const wchar_t *> wcsub_match;
typedef sub_match<std::string::const_iterator> ssub_match;
typedef sub_match<std::wstring::const_iterator> wssub_match;
typedef csub_match u8ccsub_match;
typedef ssub_match u8cssub_match;

typedef match_results<const char *> cmatch;
typedef match_results<const wchar_t *> wcmatch;
typedef match_results<std::string::const_iterator> smatch;
typedef match_results<std::wstring::const_iterator> wsmatch;
typedef cmatch u8ccmatch;
typedef smatch u8csmatch;

typedef basic_regex<char> regex;
typedef basic_regex<wchar_t> wregex;
typedef basic_regex<char, u8regex_traits<char> > u8cregex;

typedef regex_iterator<const char *> cregex_iterator;
typedef regex_iterator<const wchar_t *> wcregex_iterator;
typedef regex_iterator<std::string::const_iterator> sregex_iterator;
typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;

typedef regex_iterator<const char *, std::iterator_traits<const char *>::value_type, u8regex_traits<std::iterator_traits<const char *>::value_type> > u8ccregex_iterator;
typedef regex_iterator<std::string::const_iterator, std::iterator_traits<std::string::const_iterator>::value_type, u8regex_traits<std::iterator_traits<std::string::const_iterator>::value_type> > u8csregex_iterator;

typedef regex_iterator2<const char *> cregex_iterator2;
typedef regex_iterator2<const wchar_t *> wcregex_iterator2;
typedef regex_iterator2<std::string::const_iterator> sregex_iterator2;
typedef regex_iterator2<std::wstring::const_iterator> wsregex_iterator2;

typedef regex_iterator2<const char *, u8cregex> u8ccregex_iterator2;
typedef regex_iterator2<std::string::const_iterator, u8cregex> u8csregex_iterator2;

typedef regex_token_iterator<const char *> cregex_token_iterator;
typedef regex_token_iterator<const wchar_t *> wcregex_token_iterator;
typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;

typedef regex_token_iterator<const char *, std::iterator_traits<const char *>::value_type, u8regex_traits<std::iterator_traits<const char *>::value_type> > u8ccregex_token_iterator;
typedef regex_token_iterator<std::string::const_iterator, std::iterator_traits<std::string::const_iterator>::value_type, u8regex_traits<std::iterator_traits<std::string::const_iterator>::value_type> > u8csregex_token_iterator;

#if defined(WCHAR_MAX)
	#if (WCHAR_MAX >= 0x10ffff)
		typedef wcsub_match u32wcsub_match;
		typedef wssub_match u32wssub_match;
		typedef u32wcsub_match u1632wcsub_match;
		typedef u32wssub_match u1632wssub_match;

		typedef wcmatch u32wcmatch;
		typedef wsmatch u32wsmatch;
		typedef u32wcmatch u1632wcmatch;
		typedef u32wsmatch u1632wsmatch;

		typedef wregex u32wregex;
		typedef u32wregex u1632wregex;

		typedef wcregex_iterator u32wcregex_iterator;
		typedef wsregex_iterator u32wsregex_iterator;
		typedef u32wcregex_iterator u1632wcregex_iterator;
		typedef u32wsregex_iterator u1632wsregex_iterator;

		typedef wcregex_iterator2 u32wcregex_iterator2;
		typedef wsregex_iterator2 u32wsregex_iterator2;
		typedef u32wcregex_iterator2 u1632wcregex_iterator2;
		typedef u32wsregex_iterator2 u1632wsregex_iterator2;

		typedef wcregex_token_iterator u32wcregex_token_iterator;
		typedef wsregex_token_iterator u32wsregex_token_iterator;
		typedef u32wcregex_token_iterator u1632wcregex_token_iterator;
		typedef u32wsregex_token_iterator u1632wsregex_token_iterator;
	#elif (WCHAR_MAX >= 0xffff)
		typedef wcsub_match u16wcsub_match;
		typedef wssub_match u16wssub_match;
		typedef u16wcsub_match u1632wcsub_match;
		typedef u16wssub_match u1632wssub_match;

		typedef wcmatch u16wcmatch;
		typedef wsmatch u16wsmatch;
		typedef u16wcmatch u1632wcmatch;
		typedef u16wsmatch u1632wsmatch;

		typedef basic_regex<wchar_t, u16regex_traits<wchar_t> > u16wregex;
		typedef u16wregex u1632wregex;

		typedef regex_iterator<const wchar_t *, std::iterator_traits<const wchar_t *>::value_type, u16regex_traits<std::iterator_traits<const wchar_t *>::value_type> > u16wcregex_iterator;
		typedef regex_iterator<std::wstring::const_iterator, std::iterator_traits<std::wstring::const_iterator>::value_type, u16regex_traits<std::iterator_traits<std::wstring::const_iterator>::value_type> > u16wsregex_iterator;
		typedef u16wcregex_iterator u1632wcregex_iterator;
		typedef u16wsregex_iterator u1632wsregex_iterator;

		typedef regex_iterator2<const wchar_t *, u16wregex> u16wcregex_iterator2;
		typedef regex_iterator2<std::wstring::const_iterator, u16wregex> u16wsregex_iterator2;
		typedef u16wcregex_iterator2 u1632wcregex_iterator2;
		typedef u16wsregex_iterator2 u1632wsregex_iterator2;

		typedef regex_token_iterator<const wchar_t *, std::iterator_traits<const wchar_t *>::value_type, u16regex_traits<std::iterator_traits<const wchar_t *>::value_type> > u16wcregex_token_iterator;
		typedef regex_token_iterator<std::wstring::const_iterator, std::iterator_traits<std::wstring::const_iterator>::value_type, u16regex_traits<std::iterator_traits<std::wstring::const_iterator>::value_type> > u16wsregex_token_iterator;
		typedef u16wcregex_token_iterator u1632wcregex_token_iterator;
		typedef u16wsregex_token_iterator u1632wsregex_token_iterator;
	#endif
#endif

#if defined(__cpp_unicode_characters)
	typedef sub_match<const char16_t *> u16csub_match;
	typedef sub_match<const char32_t *> u32csub_match;
	typedef sub_match<std::u16string::const_iterator> u16ssub_match;
	typedef sub_match<std::u32string::const_iterator> u32ssub_match;

	typedef match_results<const char16_t *> u16cmatch;
	typedef match_results<const char32_t *> u32cmatch;
	typedef match_results<std::u16string::const_iterator> u16smatch;
	typedef match_results<std::u32string::const_iterator> u32smatch;

	typedef basic_regex<char16_t> u16regex;
	typedef basic_regex<char32_t> u32regex;

	typedef regex_iterator<const char16_t *> u16cregex_iterator;
	typedef regex_iterator<const char32_t *> u32cregex_iterator;
	typedef regex_iterator<std::u16string::const_iterator> u16sregex_iterator;
	typedef regex_iterator<std::u32string::const_iterator> u32sregex_iterator;

	typedef regex_iterator2<const char16_t *> u16cregex_iterator2;
	typedef regex_iterator2<const char32_t *> u32cregex_iterator2;
	typedef regex_iterator2<std::u16string::const_iterator> u16sregex_iterator2;
	typedef regex_iterator2<std::u32string::const_iterator> u32sregex_iterator2;

	typedef regex_token_iterator<const char16_t *> u16cregex_token_iterator;
	typedef regex_token_iterator<const char32_t *> u32cregex_token_iterator;
	typedef regex_token_iterator<std::u16string::const_iterator> u16sregex_token_iterator;
	typedef regex_token_iterator<std::u32string::const_iterator> u32sregex_token_iterator;
#endif

#if defined(__cpp_char8_t)
	#if defined(__cpp_lib_char8_t)
	#define SRELLTMP_U8S_CI std::u8string::const_iterator
	#else
	#define SRELLTMP_U8S_CI std::basic_string<char8_t>::const_iterator
	#endif
	typedef sub_match<const char8_t *> u8csub_match;
	typedef sub_match<SRELLTMP_U8S_CI> u8ssub_match;

	typedef match_results<const char8_t *> u8cmatch;
	typedef match_results<SRELLTMP_U8S_CI> u8smatch;

	typedef basic_regex<char8_t> u8regex;

	typedef regex_iterator<const char8_t *> u8cregex_iterator;
	typedef regex_iterator<SRELLTMP_U8S_CI> u8sregex_iterator;

	typedef regex_iterator2<const char8_t *> u8cregex_iterator2;
	typedef regex_iterator2<SRELLTMP_U8S_CI> u8sregex_iterator2;

	typedef regex_token_iterator<const char8_t *> u8cregex_token_iterator;
	typedef regex_token_iterator<SRELLTMP_U8S_CI> u8sregex_token_iterator;
	#undef SRELLTMP_U8S_CI
#else
	typedef u8ccsub_match u8csub_match;
	typedef u8cssub_match u8ssub_match;

	typedef u8ccmatch u8cmatch;
	typedef u8csmatch u8smatch;

	typedef u8cregex u8regex;

	typedef u8ccregex_iterator u8cregex_iterator;
	typedef u8csregex_iterator u8sregex_iterator;

	typedef u8ccregex_iterator2 u8cregex_iterator2;
	typedef u8csregex_iterator2 u8sregex_iterator2;

	typedef u8ccregex_token_iterator u8cregex_token_iterator;
	typedef u8csregex_token_iterator u8sregex_token_iterator;
#endif

#undef SRELL_FORCEINLINE
#undef SRELL_IFCE
#undef SRELL_STACON
#undef SRELL_NOEXCEPT
#undef SRELL_NO_VCWARNING_END
#undef SRELL_NO_VCWARNING

}		//  namespace srell

#undef SRELL_AT_SSE42
#undef SRELL_HAS_SSE42
#undef SRELL_HAS_TYPE_TRAITS

#endif	//  SRELL_HPP_