<!doctype html>
<html lang="en">
<head>
	<meta charset="utf-8">
	<title>Enhancement of regex</title>
	<style>
	body
	{
		color: #000000;
		background-color: #fcfcfc;
	}
	div.changes
	{
		margin-right: 0.3em;
		margin-bottom: 1.2em;
		padding: 0.3em 1.2em;
		background-color: #f3f3f3;
	}
	div.changes del,
	div.changes del *
	{
		text-decoration: line-through;
		background-color: #efdfdf;
		color: #7f00df;
		padding-right: 1px;
	}
	div.changes ins, p.changes ins, h4.changes ins
	{
		text-decoration: none;
/*
		text-decoration: underline;
		border-bottom: 1px solid #00007f;
*/
		background-color: #dfdfef;
		color: #007f7f;
		padding: 0.3em 1px;
	}
	div.changes ins *
	{
		background-color: #dfdfef;
		color: #007f7f;
	}
	div.changes p.indent, div.indent
	{
		padding-left: 1.2em;
		position: relative;
		text-indent: 0;
	}
	div.changes div.indent
	{
		margin-top: 1.2em;
		margin-bottom: 1.2em;
	}
	div.changes p.indent span.num,
	div.changes div.indent span.num
	{
		position: absolute;
		left: -0.3em;
	}
	div.changes ul.indent li
	{
		list-style-type: none;
		position: relative;
		padding-left: 3.2em;
		text-indent: -1.333em;
	}
	div.changes ul.indent li span.num
	{
		position: absolute;
		left: -1.6em;
	}
	div.changes h4
	{
		font-size: 1em;
		font-weight: bold;
		margin: 0.8em -0.4em;
	}
	dl
	{
		border: 1px solid #bfbfbf;
		border-radius: 0.6em;
		margin-bottom: 1.2em;
	}
	dl dt
	{
		background-color: #dfdffc;
		background-color: #dfdfbf;
		padding: 2px 6px 2px 0.6em;
	}
	em.del
	{
		font-style: normal;
		text-decoration: line-through;
		padding-right: 1px;
	}
	em.ins
	{
		font-style: normal;
		text-decoration: underline;
		padding-left: 1px;
	}
	p
	{
		text-indent: 1.2em;
	}
	p, div, li
	{
		line-height: 1.6em;
	}
	p.novm
	{
		margin-top: 0;
		margin-bottom: 0;
	}
	p.padb
	{
		margin-top: 0;
		margin-bottom: 0;
		padding-bottom: 1.2em;
	}
	pre.code
	{
		border: 6px double #bfbfbf;
		padding: 6px 12px;
/*
		color: #ffffff;
		background: #000000;
*/
	}
	li p
	{
		text-indent: 0;
	}
	code, code *,
	div.code, div.code *,
	p.code, p.code *
	{
		font-family: courier new, monospace;
		color: #3f3f3f;
		font-weight: bold;
	}
	code, div.code, p.code
	{
		font-size: 90%;
	}
	div.code p
	{
		margin-top: 0;
		margin-bottom: 0.6em;
	}
	ol#toc
	{
		list-style-type: upper-roman;
	}
	body > section
	{
/*
		border: 1px solid #bfbfbf;
		border-radius: 0.6em;
		margin-bottom: 2.4em;
*/
		padding: 0.6em 1.2em 1.2em 1.2em;
	}
	section > h2
	{
		margin-top: 0.6em;
		padding: 0.1em 0.3em;
		background-color: #dfdfbf;
		border-radius: 0.3em;
		font-size: 1.44em;
	}
	section > section,
	section > dl > dd > section
	{
		border: 1px solid #bfbfbf;
		border-radius: 0.6em;
		margin-bottom: 1.2em;
		padding-left: 1.2em;
	}
	span.title
	{
		font-style: italic;
	}
	table#meta th
	{
		text-align: left;
	}
	table#meta th,
	table#meta td
	{
		padding: 0 12px;
	}
	table#meta td img
	{
		vertical-align: middle;
	}
	table.defstyle
	{
		margin-top: 0.6em;
		margin-bottom: 1.2em;
		border: 1px solid #000000;
		border-spacing: 0;
	}
	table.defstyle th, table.defstyle td
	{
		border-top: 1px solid #000000;
		border-bottom: 1px solid #000000;
		padding: 6px 12px;
	}
	ul
	{
		margin-top: 1.2em;
		margin-bottom: 1.2em;
	}
	ul.changes
	{
		list-style-type: square;
	}
	ul.changes > li
	{
		margin-bottom: 1.8em;
	}
	ul.changes h4.target
	{
/*
		background-color: #dfdffc;
		padding: 2px 6px 2px 0.6em;
		margin-bottom: 0;
		border: 3px double #7f7fbf;
		font-weight: bold;
*/
	}
	</style>
</head>
<body>

<table id="meta">
	<tr>
		<th>Document Number</th>
		<td>P1844R0</td>
	</tr>
	<tr>
		<th>Date</th>
		<td>2019-08-04</td>
	</tr>
	<tr>
		<th>Audience</th>
		<td>LEWGI, SG16</td>
	</tr>
	<tr>
		<th>Reply-To</th>
		<td>
			Nozomu Katō
			<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQcAAAAYCAIAAAB4Pq8KAAAERElEQVR4nO2aPXKjMBTH3+7oCMyEVOlNQUoOQIGr3GFdqKSg2hOkckGpgr3DVqHgAC5DIfdbLTvDEVRsAcZCCAkZJ1ln368Effz10PuQ7C9CCEAQROLrRwtAkH8O9AoEUUGvQBCV2/YKXhBS8I9WYeEmRJr5BEtw4ra94n240T3xXrLbKiMkq9q3n+ndIB8tALl1vHj/2e4xF+SKtso+VyRA/kt4sTijmbyirTJCCPET2D564+FJwYEX5IQ6W99z8lLqMtt3Bd20w4DqbMZyYq4xL0hIAWholrt8LkWk2lmxltnOMGvqedmK0l7otNwyFGAaO68s1caizoPNbSRpXrlJVrWjPqMeQcTyxLduBIA5r+hE+gmUjRBC7GNPbUFDcohER1NC4p9n4gXxk03dvxT1JvFPOoKdkKgZALBv08Evoq2yTrCsltXSbDQ0e6C2cbATNZPeaWzhMNdUZFtlJDx2du6tJfc02BlMpp6RzQt5MiFqdvztGJS0dl6DYgHRlMcDN6/uDA2f4fupX5onPiHDg5rlybNky3731ayLFabNIEY0Zdo9lj7xhJG5h179k6ZMIZXsrn/UjzJ96sagpClT62h6GQsaT9Z7YXedSJMtjXbWL8gie94E08byE7OdL7CP0lunyb6R1HkV81i2WM26na5rIOWKtsrOvrkLHLzdu98Mg7y+5Om44ALvcZvmL6+yZ7ZVFtK0/H6dcMMLP4Gy0QUvKTX7SW4dx6Gxa3etSH6gkD7cSU+8x20KMwFcsjMsNvXktZJvHDDY+WL4gYK6CoCLVjfh7iGdf9lljqYETQaSvMKL96Ipj6GlLr4CbfWc5NfyCRqSkAJs7tXB2iojcmoe8qBekkNj9+6zIgGgL3bX+ONiRt/YUkUomJawkrcY04p8SlBzgHKu8OJ9l13spdfFtNVzkrP6ahGH1aJmMCnk+c8kT5cGNqfGl3SfEdm/UrlqNFbpv7HQHVRMGJawEuezzSr6lH6KYTpb60/bcnZxcw5dkhslQ174Sc5qpwrNCIsCCHbdUUsV6hSEjI3tH87YfU5kEDGgh8vystXUVtmmam2Cyc4rCCIG+a8/Wm221TlycgfaxSFD6DHdzPZBpSnBoZbz4m8sH19J+Ul+umniRUhhqU90V2zLYpkX77sPNjS/e0iB/pAuJE2libFxEDEwl7ML55qKhOCpTJXwy4vFazaZWidbGZr/TE67LIjYeAUkpPo5J0swY/2IEwu0VVZw6+rc4Qfan6yt22/Br3hevHfK6MFuVLqGx6Fwa6sfFKRLdNfS1qqzZkDDfkQv3tfsXLMfItNRwdw42J1fauUun0sR2Vf62xfpaBEey6eFmXTe1HrZQcRk44fHc9UnNybkEA13NPYlrMSL992t63Cw2kSBfXXOBLvFlekX8dl+rUeQteC/AxFEBb0CQVTQKxBEBb0CQVTQKxBEBb0CQVT+ApW0PBTiamq1AAAAAElFTkSuQmCC" alt="">
		</td>
	</tr>
	<tr>
		<th>
			Supersedes
		</th>
		<td>
			<a href="https://wg21.link/P0169">P0169</a>
		</td>
	</tr>
</table>

<h1>Enhancement of regex</h1>

<section>
	<h2>Table of Contents</h2>
	<ol id="toc">
		<li><a href="#sec1">Introduction and Motivation</a></li>
		<li><a href="#sec2">Why new syntax option? Why not simply enhance the existing ECMAScript mode?</a></li>
		<li><a href="#sec3">Why RegExp of ECMAScript?</a></li>
		<li><a href="#sec4">Scope and Impact on the Standard</a></li>
		<li><a href="#sec5">Technical Specifications</a></li>

		<li><a href="#sec6">Relevant Matter</a></li>
		<li><a href="#sec7">References</a></li>
		<li><a href="#sec8">Appendix</a></li>
	</ol>
	<section>
		<h3>Abstract</h3>
		<ul>
			<li>Leave the existing <code>std::regex</code> and <code>std::wregex</code> as they are. They may have problems, but we should not use our time to make them better and/or convenient.</li>
			<li>Instead, add a new syntax option being compliant to a recent version of ECMAScript keeping the nature of being locale independent, for use with <code>char8_t</code>, <code>char16_t</code>, or <code>char32_t</code> through the template specialization and urge to migrate to them.</li>
			<li>These three specializations are not required necessarily to be implemented separately. It is expected that typical implementations use an internal iterator class template that translates a sequence of UTF-8, UTF-16, or UTF-32 to a sequence of Unicode code points and process that translated sequence. The link to a sample implementation is included.</li>
		</ul>
	</section>
</section>

<section>
	<h2 id="sec1">I. Introduction and Motivation</h2>
	<p>
	The default engine of C++'s regex is based on RegExp, regular expression objects of the ECMAScript specification third edition. Although its original RegExp had not been being modified for many years, in these years has been enhanced as follows:
	</p>
	<ul>
		<li>Unicode flag was introduced in ES6 (ES2015) to handle the surrogate pair correctly, </li>
		<li>Variable length lookbehind assertions since ES2018 (ES9), (not like Perl, but like .Net. No restriction on length of what lookbehind can match),</li>
		<li>Named capture groups since ES2018,</li>
		<li>Dotall flag corresponding to //s flag in Perl since ES2018,</li>
		<li>Unicode property escapes since ES2018.</li>
	</ul>
	<p>
	Unfortunately, while C++'s regex supports six regular expression grammars, all are inferior to other languages' regular expression features in richness of available expressions nowadays. In addition, the problem of how to support Unicode is still unsettled. To resolve these problems, or at least to improve the current situation, this paper proposes adding the new syntax option, <code>ECMAScript2019</code> to regex.
	</p>
</section>

<section>
	<h2 id="sec2">II. Why new syntax option? Why not simply enhance the existing ECMAScript engine?</h2>
	<p>
	Short answer: The ECMAScript engine of C++ has been modified to depend on the locale deeply. The author of this proposal wants to release regex from the locale and to revert it to being locale independent as its original RegExp, then to add new features on it. But doing so involves deprecating some features of the default engine and seems to be difficult.
	</p>
	<p>
	Long answer: RegExp of ECMAScript is locale independent and treats an input sequence as UTF-16. For example, <code>/[a-z]/</code> is always interpreted "any character in the range from U+0061 to U+007A inclusive". This has the benefit of allowing that the set of characters that some character class expression matches can be settled even at compile time. This is true even if the <code>icase</code> flag is set, by preparing a reversed case-folding table (while case-folding means converting each of <code>"S"</code>, <code>"s"</code>, and <code>U"ſ"</code> to <code>"s"</code>, reversed case-folding here means returning the set of characters that are converted into the same character when case-folding is done, such as converting each of <code>"S"</code>, <code>"s"</code>, and <code>U"ſ"</code> to <code>U"Ssſ"</code>.)
	</p>
	<p>
	However, the ECMAScript engine of regex can be modified as being locale sensitive by setting the <code>collate</code> flag. If this flag is used with the <code>icase</code> flag, the pattern compiler is required to call <code>std::tolower</code> and <code>std::toupper</code> per character in one character class [] for gathering all characters that the character class can match. This clumsiness was filed as <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#523">Defect Report 523</a> in 2005 and is still Status Open.
	</p>
	<p>
	Furthermore, the ECMAScript engine was modified to support the POSIX character class and to change the expressions <code>\d</code>, <code>\D</code>, <code>\s</code>, <code>\S</code>, <code>\w</code>, and <code>\W</code> to be equivalent to some of the POSIX character class. This also made the ECMAScript engine depend on the locale.
	</p>
	<p>
	Although this paper is not intended to propose making regex <code>constexpr</code>, if there is any ECMAScript based engine that inherits the nature of being locale independent from its original RegExp, it might make <code>constexpr</code> support easier than now.
	</p>
	<p>
	The modifications defined in [re.grammar] also caused <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2986">DR2986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2987">DR2987</a> and they are still unresolved. To fix these issues originating in the modifications, I considered to propose deprecating all the modifications and reverting the ECMAScript engine to its original specification of RegExp, before adding something new on it. But the ECMAScript engine is the default one of regex. Trying to deprecate some features of it seems to increase difficulty in getting the proposal accepted.
	</p>
	<p>
	Moreover, while RegExp supports UTF-16 only, C++'s regex needs to support various character sets. It is a difficult question how Unicode property escapes should be processed in legacy (non-Unicode based) character sets.
	</p>

	<p>
	Thus, this paper does not touch any part of the current ECMAScript engine and leaves it as is for legacy character sets that use <code>char</code> and <code>wchar_t</code>; and instead propose introducing a new syntax option being compliant to a recent version of ECMAScript keeping the nature of being locale independent, for use with <code>char8_t</code>, <code>char16_t</code>, or <code>char32_t</code> through the template specialization.
	</p>
</section>

<section>
	<h2 id="sec3">III. Why RegExp of ECMAScript?</h2>
	<p>
	Because the ECMAScript specification explains the behavior of RegExp through defining closures in detail, there seems to be less room for any undefined or undocumented behaviour to appear. It would be an important factor to the standard.
	</p>
</section>

<section>
	<h2 id="sec4">IV. Scope and Impact on the Standard</h2>
	<p>
	The new syntax is implemented through the template specialization for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code>. As of C++20, <code>&lt;regex&gt;</code> supports only <code>char</code> and <code>wchar_t</code> and compiling <code>basic_regex</code> with the other types leads to compile time error by the reasons explained in P0169. So, the existing implementations would not be affected by this proposal except <code>regex_iterator</code>.
	</p>
	<dl>
		<dt>basic_regex</dt>
		<dd>
			<p>
			When the first template parameter <code>charT</code> of the <code>basic_regex</code> class is <code>char8_t</code>, <code>char16_t</code>, or <code>char32_t</code>, its constructors and assign functions are required to interpret an input sequence as UTF-8, UTF-16, or UTF-32 respectively. In addition, <code>syntax_option_type</code>s other than <code>icase</code>, <code>nosubs</code>, <code>optimize</code>, and <code>multiline</code> are disabled. An input sequence is always interpreted assuming that <code>ECMAScript2019</code> is set.
			</p>
			<p>
			These three specializations are not required necessarily to be implemented separately. It is expected that typical implementations use an internal iterator class template that translates a sequence of UTF-8, UTF-16, or UTF-32 to a sequence of Unicode code points and construct a finite state machine by parsing that translated sequence in their common base class.
			</p>
			<p>
			One obstacle to implementing in such a way is the expression <code>\xHH</code> where H is a hexadecimal digit. In the spec of ECMAScript this expression is defined to represent a code unit. However, appearance of an isolated code unit in a UTF-8 sequence requires special treatment, because unlike in UTF-16 and UTF-32, an isolated code unit in UTF-8 cannot be converted to any code point when its value is in 0x80-0xff inclusive. (This does not matter in ECMAScript, since it supports UTF-16 only.)
			</p>
			<p>
			To simplify things, in the proposed <code>ECMAScript2019</code> syntax, the expression <code>\xHH</code> is changed to represent a code point value. This is the one and only modification to the spec of ECMAScript.
			</p>
			<p>
			(If the committee does not like the inconsistency with the meaning of C++'s own <code>\xHH</code>, the previous paragraph will be changed to "... use of the expression <code>\xHH</code> is disabled". RegExp has <code>\uHHHH</code> and <code>\u{H...}</code> for representing a code point. Removing support for <code>\xHH</code> is not likely to cause inconvenience.)
			</p>
		</dd>

		<dt>regex_traits</dt>
		<dd>
			<p>
			<code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, and <code>basic_regex&lt;char32_t&gt;</code> must be locale independent. It means that these specializations have to construct an internal finite state machine only based on the Unicode code point values that are translated from the input sequence and may not use <code>regex_traits</code>.
			</p>
			<p>
			Thus, <code>regex_traits</code> does not need to be specialized for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code>.
			</p>
			<p>
			Particularly, when <code>basic_regex</code> is used with <code>char8_t</code>, <code>char16_t</code>, or <code>char32_t</code>, case-folding may not be performed using <code>regex_traits&lt;charT&gt;::translate_nocase()</code>, but performed as defined in the ECMAScript specification.
			</p>
		</dd>

		<dt>Algorithm functions (regex_match, regex_search, and regex_replace)</dt>
		<dd>
			<p>
			As these take an instance of the <code>basic_regex</code> class as a parameter, they get <code>charT</code> as<!-- the third (<code>regex_match</code> and <code>regex_search</code>) or fourth (<code>regex_replace</code>) --> a template parameter. So, they also can be implemented in a way similar to <code>basic_regex</code> using the template specialization.
			</p>
			<section>
				<h3>regex_match and regex_search</h3>
				<p>
				The proposed <code>ECMAScrip2019</code> syntax supports lookbehind assertions, which none of the existing six engines of C++'s regex has support for. When performing a lookbehind assertion, the algorithm function reads the input sequence backwards. This raises a new issue.
				</p>
				<p>
				When a user wants to find all the portions that some regular expression matches against some input sequence, the user will call <code>regex_search</code> against the subrange [the end of the previous matched portion of the entire sequence, the end of the entire sequence) while the previous call succeeds. In this case, the subrange [the beginning of the entire sequence, the end of the previous matched portion of the entire sequence) is also a valid range and it is safe for an algorithm function to read a character in that subrange.
				</p>
				<p>
				However, there is no way at this time to inform an algorithm function about the limit until where it can read backwards for lookbehind.
				</p>
				<p>
				For example, when a user calls <code>regex_search</code> with the regular expression <code>/(?&lt;!\d{2,})ABC123/</code> ("ABC123" not preceded by two or more digit characters) against "ABC123ABC1234ABC12345", only the first six characters should be matched, because the second and later "ABC123"s are all preceded by two or more digits. But if there is no way to tell <code>regex_search</code> about until where it can look-behind, the second and later call to <code>regex_search</code> against [end of previous matched subsequence, end of entire sequence) also return <code>"abc123".</code>
				</p>
				<p>
				The <code>match_prev_avail</code> flag is not suitable for this purpose. It only indicates that the preceding one point is a valid iterator position.
				</p>
				<p>
				As of C++20, both <code>regex_match</code> and <code>regex_search</code> take as an input sequence 1) two bidirectional iterators that specify [begin, end), 2) const reference to an instance of <code>std::basic_string</code>, or 3) a pointer to a null-terminated string. To fix the problem mentioned above, this paper proposes adding new overload functions that take three bidirectional iterators, which specify [begin, end) and the limit of lookbehind, to both <code>regex_match</code> and <code>regex_search</code>.
				</p>
				<p>
				This addition is useful only when an algorithm function is used with an instance of <code>basic_regex</code> constructed with <code>char8_t</code>, <code>char16_t</code>, or <code>char32_t</code>. If any variant of algorithm functions that takes three bidirectional iterators is called when its <code>charT</code> is <code>char</code> or <code>wchar_t</code>, the third iterator for specifying the limit of lookbehind is simply ignored.
				</p>
			</section>
			<p>
			No specialization is proposed for <code>regex_replace</code>. It does not do matching by itself but uses <code>regex_iterator</code> that calls <code>regex_search</code> internally.
			</p>
		</dd>
		<dt>match_results</dt>
		<dd>
			<p>
			It is preferable that 1) the new function <code>group()</code> and its overload functions be added to <code>match_results</code> for access to captured sequences by group name, and 2) the member function <code>format()</code> be modified to support the replacement text symbol <code>$&lt;GROUPNAME&gt;</code> that was introduced in ES2018.
			</p>
			<p>
			However, as <code>match_results</code> does not take <code>charT</code> as a template parameter, it is not easy to implement something specific to the proposed <code>ECMAScript2019</code> syntax option through the template specialization.
			</p>
			<p>
			Thus, in this proposal, the new member function <code>gname_to_gnumber()</code> and its overload functions that convert a group name to the group number assigned with it, are added instead into <code>basic_regex</code> specialized for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code>.
			</p>
		</dd>
		<dt>regex_iterator</dt>
		<dd>
			<p>
			<code>regex_iterator</code> is changed to use one variant of <code>regex_search</code> that takes three bidirectional iterators mentioned above, instead of the current one that takes two bidirectional iterators. In this proposal this is the only proposed change that requires modifications to the existing implementations.
			</p>
			<p>
			Whether this change breaks ABI is likely to depend on the efficiency of the compiler. Because non-specialized <code>regex_search</code> that takes three bidirectional iterators only calls a variant that takes two bidirectional iterators, <code>regex_iterator</code> ends up calling the variant that it calls at present indirectly when the type of its second template parameter is not <code>char8_t</code>, <code>char16_t</code>, or <code>char32_t</code>. So, it is possible that the output of the compiler is unchanged particularly when optimization is enabled.
			</p>
			<p>
			This change can be avoided by providing six template specializations for <code>const char(8|16|32)_t *</code> and <code>std::u(8|16|32)string::const_iterator</code>. But the author of this proposal thinks that <code>regex_iterator</code> and what depends on it, namely <code>regex_token_iterator</code> and <code>regex_replace</code>, are supplements to rather than the core of regex and so in this case the simplest way to implement is preferable. Thus, the "modifying" solution is proposed.
			</p>
		</dd>
	</dl>
	<p>
	The link to a sample implementation based on the method above is shown in the Appendix section of this document.
	</p>
</section>

<section>
	<h2 id="sec5">V. Technical Specifications</h2>

	<section>
		<h3>1. &lt;regex&gt;</h3>
		<p>
		The following changes are proposed:
		</p>
		<ul class="changes">
			<li>
				<h4 class="target">
				30.1 General [re.general]
				</h4>
				<div class="changes">
					<p class="indent">
					<span class="num">2</span>
					The following subclauses describe a basic regular expression class template and its traits that can handle char-like (21.1) template arguments, <del>two</del><ins>five</ins> specializations of this class template that handle sequences of <code>char</code> <del>and</del><ins>,</ins> <code>wchar_t</code><ins>, <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code></ins>, a class template that holds the result of a regular expression match, a series of algorithms that allow a character sequence to be operated upon by a regular expression<ins>, three specializations of this series that handle sequences of <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code></ins>, and two iterator types for enumerating regular expression matches, as summarized in Table 122.
					</p>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.4 Header &lt;regex&gt; synopsis [re.syn]
				</h4>
				<div class="changes">
					<div class="indent">
						<i>// 30.8, class template</i> <code>basic_regex</code>
						<div class="code">
							<p>
							template&lt;class charT, class traits = regex_traits&lt;charT&gt;&gt; class basic_regex;
							</p>
							<p>
							using regex = basic_regex&lt;char&gt;;<br>
							using wregex = basic_regex&lt;wchar_t&gt;;<br>
							<ins>
							using u8regex = basic_regex&lt;char8_t&gt;;<br>
							using u16regex = basic_regex&lt;char16_t&gt;;<br>
							using u32regex = basic_regex&lt;char32_t&gt;;
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<i>// 30.9, class template</i> <code>sub_match</code>
						<div class="code">
							<p>
							template&lt;class BidirectionalIterator&gt;<br>
							&nbsp;&nbsp;class sub_match;
							</p>
							<p>
							using csub_match = sub_match&lt;const char*&gt;;<br>
							using wcsub_match = sub_match&lt;const wchar_t*&gt;;<br>
							<ins>
							using u8csub_match = sub_match&lt;const char8_t*&gt;;<br>
							using u16csub_match = sub_match&lt;const char16_t*&gt;;<br>
							using u32csub_match = sub_match&lt;const char32_t*&gt;;<br>
							</ins>
							using ssub_match = sub_match&lt;string::const_iterator&gt;;<br>
							using wssub_match = sub_match&lt;wstring::const_iterator&gt;;<br>
							<ins>
							using u8ssub_match = sub_match&lt;u8string::const_iterator&gt;;<br>
							using u16ssub_match = sub_match&lt;u16string::const_iterator&gt;;<br>
							using u32ssub_match = sub_match&lt;u32string::const_iterator&gt;;
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<i>// 30.10, class template</i> <code>match_results</code>
						<div class="code">
							<p>
							template&lt;class BidirectionalIterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class Allocator = allocator&lt;sub_match&lt;BidirectionalIterator&gt;&gt;&gt;<br>
							&nbsp;&nbsp;class match_results;
							</p>
							<p>
							using cmatch = match_results&lt;const char*&gt;;<br>
							using wcmatch = match_results&lt;const wchar_t*&gt;;<br>
							<ins>
							using u8cmatch = match_results&lt;const u8char_t*&gt;;<br>
							using u16cmatch = match_results&lt;const u16char_t*&gt;;<br>
							using u32cmatch = match_results&lt;const u32char_t*&gt;;<br>
							</ins>
							using smatch = match_results&lt;string::const_iterator&gt;;<br>
							using wsmatch = match_results&lt;wstring::const_iterator&gt;;<br>
							<ins>
							using u8smatch = match_results&lt;u8string::const_iterator&gt;;<br>
							using u16smatch = match_results&lt;u16string::const_iterator&gt;;<br>
							using u32smatch = match_results&lt;u32string::const_iterator&gt;;
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<i>// 30.11.2, function template</i> <code>regex_match</code>
						<div class="code">
							<p>
							template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class BidirectionalIterator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class charT, class Allocator, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(const charT* str, match_results&lt;const charT*, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class ST, class SA, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(const basic_string&lt;charT, ST, SA&gt;&amp; s,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;typename basic_string&lt;charT, ST, SA&gt;::const_iterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class ST, class SA, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(const basic_string&lt;charT, ST, SA&gt;&amp;&amp;,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;typename basic_string&lt;charT, ST, SA&gt;::const_iterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Allocator&gt;&amp;,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp;,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type = regex_constants::match_default) = delete;<br>
							template&lt;class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(const charT* str,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class ST, class SA, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(const basic_string&lt;charT, ST, SA&gt;&amp; s,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							<ins>
							template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
							</ins>
							</p>
							<p>
							<ins>
							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<i>// 30.11.3, function template</i> <code>regex_search</code>
						<div class="code">
							<p>
							template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class BidirectionalIterator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class charT, class Allocator, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(const charT* str,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;const charT*, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(const charT* str,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class ST, class SA, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(const basic_string&lt;charT, ST, SA&gt;&amp; s,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class ST, class SA, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(const basic_string&lt;charT, ST, SA&gt;&amp; s,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;typename basic_string&lt;charT, ST, SA&gt;::const_iterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>
							template&lt;class ST, class SA, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(const basic_string&lt;charT, ST, SA&gt;&amp;&amp;,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;typename basic_string&lt;charT, ST, SA&gt;::const_iterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Allocator&gt;&amp;,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp;,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;= regex_constants::match_default) = delete;<br>
							<ins>
							template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class charT, class traits&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
							</ins>
							</p>
							<p>
							<ins>
							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);<br>

							template&lt;class BidirectionalIterator, class Allocator&gt;<br>
							&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;&amp; e,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<i>// 30.12.1, class template</i> <code>regex_iterator</code>
						<div class="code">
							<p>
							template&lt;class BidirectionalIterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class charT = typename iterator_traits&lt;BidirectionalIterator&gt;::value_type,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class traits = regex_traits&lt;charT&gt;&gt;<br>
							&nbsp;&nbsp;class regex_iterator;
							</p>
							<p>
							using cregex_iterator = regex_iterator&lt;const char*&gt;;<br>
							using wcregex_iterator = regex_iterator&lt;const wchar_t*&gt;;<br>
							<ins>
							using u8cregex_iterator = regex_iterator&lt;const char8_t*&gt;;<br>
							using u16cregex_iterator = regex_iterator&lt;const char16_t*&gt;;<br>
							using u32cregex_iterator = regex_iterator&lt;const char32_t*&gt;;<br>
							</ins>
							using sregex_iterator = regex_iterator&lt;string::const_iterator&gt;;<br>
							using wsregex_iterator = regex_iterator&lt;wstring::const_iterator&gt;;<br>
							<ins>
							using u8sregex_iterator = regex_iterator&lt;u8string::const_iterator&gt;;<br>
							using u16sregex_iterator = regex_iterator&lt;u16string::const_iterator&gt;;<br>
							using u32sregex_iterator = regex_iterator&lt;u32string::const_iterator&gt;;
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<i>// 30.12.2, class template</i> <code>regex_token_iterator</code><br>
						<div class="code">
							<p>
							template&lt;class BidirectionalIterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class charT = typename iterator_traits&lt;BidirectionalIterator&gt;::value_type,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class traits = regex_traits&lt;charT&gt;&gt;<br>
							&nbsp;&nbsp;class regex_token_iterator;
							</p>
							<p>
							using cregex_token_iterator = regex_token_iterator&lt;const char*&gt;;<br>
							using wcregex_token_iterator = regex_token_iterator&lt;const wchar_t*&gt;;<br>
							<ins>
							using u8cregex_token_iterator = regex_token_iterator&lt;const char8_t*&gt;;<br>
							using u16cregex_token_iterator = regex_token_iterator&lt;const char16_t*&gt;;<br>
							using u32cregex_token_iterator = regex_token_iterator&lt;const char32_t*&gt;;<br>
							</ins>
							using sregex_token_iterator = regex_token_iterator&lt;string::const_iterator&gt;;<br>
							using wsregex_token_iterator = regex_token_iterator&lt;wstring::const_iterator&gt;;<br>
							<ins>
							using u8sregex_token_iterator = regex_token_iterator&lt;u8string::const_iterator&gt;;<br>
							using u16sregex_token_iterator = regex_token_iterator&lt;u16string::const_iterator&gt;;<br>
							using u32sregex_token_iterator = regex_token_iterator&lt;u32string::const_iterator&gt;;
							</ins>
							</p>
						</div>
					</div>

					<div class="indent">
						<div class="code">
							<p>
							namespace pmr {<br>
							&nbsp;&nbsp;template&lt;class BidirectionalIterator&gt;<br>
							&nbsp;&nbsp;&nbsp;&nbsp;using match_results =<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;std::match_results&lt;BidirectionalIterator,<br>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;polymorphic_allocator&lt;sub_match&lt;BidirectionalIterator&gt;&gt;&gt;;
							</p>
							<p>
							&nbsp;&nbsp;using cmatch = match_results&lt;const char*&gt;;<br>
							&nbsp;&nbsp;using wcmatch = match_results&lt;const wchar_t*&gt;;<br>
							<ins>
							&nbsp;&nbsp;using u8cmatch = match_results&lt;const char8_t*&gt;;<br>
							&nbsp;&nbsp;using u16cmatch = match_results&lt;const char16_t*&gt;;<br>
							&nbsp;&nbsp;using u32cmatch = match_results&lt;const char32_t*&gt;;<br>
							</ins>
							&nbsp;&nbsp;using smatch = match_results&lt;string::const_iterator&gt;;<br>
							&nbsp;&nbsp;using wsmatch = match_results&lt;wstring::const_iterator&gt;;<br>
							<ins>
							&nbsp;&nbsp;using u8smatch = match_results&lt;u8string::const_iterator&gt;;<br>
							&nbsp;&nbsp;using u16smatch = match_results&lt;u16string::const_iterator&gt;;<br>
							&nbsp;&nbsp;using u32smatch = match_results&lt;u32string::const_iterator&gt;;<br>
							</ins>
							}
							</p>
						</div>
					</div>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.5.1 Bitmask type syntax_option_type [re.synopt]
				</h4>
				<div class="changes">
					<div class="indent">
						<div class="code">
							<p>
							namespace std::regex_constants {<br>
							&nbsp;&nbsp;using syntax_option_type = T1;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type icase = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type nosubs = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type optimize = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type collate = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type ECMAScript = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type basic = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type extended = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type awk = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type grep = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type egrep = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type multiline = unspecified ;<br>
							<ins>
							&nbsp;&nbsp;inline constexpr syntax_option_type ECMAScript2019 = unspecified ;<br>
							&nbsp;&nbsp;inline constexpr syntax_option_type dotall = unspecified ;<br>
							</ins>
							}
							</p>
						</div>
						<p>
						<span class="num">1</span>
						The type <code>syntax_option_type</code> is an implementation-defined bitmask type (16.4.2.2.4). Setting its elements has the effects listed in Table 124. A valid value of type <code>syntax_option_type</code> shall have at most one of the grammar elements <code>ECMAScript</code>, <code>basic</code>, <code>extended</code>, <code>awk</code>, <code>grep</code>, <code>egrep</code><ins>, <code>ECMAScript2019</code></ins>, set. If no grammar element is set, the default grammar is <ins><code>ECMAScript2019</code> when a value of type <code>syntax_option_type</code> is passed to an instance of one of the specializations <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, and <code>basic_regex&lt;char32_t&gt;</code>; otherwise </ins><code>ECMAScript</code>.
						</p>
					</div>

					<p>
					...
					</p>

					<table class="defstyle" id="table124">
						<caption>Table 124: <code>syntax_option_type</code> effects [tab:re.synopt]</caption>
						<tr>
							<th>Element</th>
							<th>Effect(s) if set</th>
						</tr>
						<tr>
							<td><code>icase</code></td>
							<td>
								Specifies that matching of regular expressions against a character container sequence shall be performed without regard to case.
							</td>
						</tr>
						<tr>
							<td><code>nosubs</code></td>
							<td>
								Specifies that no sub-expressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no sub-expression matches shall be stored in the supplied <code>match_results</code> object.
							</td>
						</tr>
						<tr>
							<td><code>optimize</code></td>
							<td>
								Specifies that the regular expression engine should pay more attention to
the speed with which regular expressions are matched, and less to the speed with which regular expression objects are constructed. Otherwise it has no detectable effect on the program output.
							</td>
						</tr>
						<tr>
							<td><code>collate</code></td>
							<td>
								Specifies that character ranges of the form "[a-b]" shall be locale sensitive.<ins> This flag has no effect when the <code>ECMAScript2019</code> engine is selected.</ins>
							</td>
						</tr>
						<tr>
							<td><code>ECMAScript</code></td>
							<td>
								Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262<ins> third edition</ins>, as modified in 30.13.<br>
								See also: ECMA-262<ins> third edition</ins> 15.10<br>
								<ins>
								If this flag is passed to an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, or <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><code>basic</code></td>
							<td>
								Specifies that the grammar recognized by the regular expression engine shall be that used by basic regular expressions in POSIX.<br>
								See also: POSIX, Base Definitions and Headers, Section 9.3<br>
								<ins>
								If this flag is passed to an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, or <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><code>extended</code></td>
							<td>
								Specifies that the grammar recognized by the regular expression engine shall
be that used by extended regular expressions in POSIX.<br>
								See also: POSIX, Base Definitions and Headers, Section 9.4<br>
								<ins>
								If this flag is passed to an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, or <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><code>awk</code></td>
							<td>
								Specifies that the grammar recognized by the regular expression engine shall
be that used by the utility awk in POSIX.<br>
								<ins>
								If this flag is passed to an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, or <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><code>grep</code></td>
							<td>
								Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep in POSIX.<br>
								<ins>
								If this flag is passed to an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, or <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><code>egrep</code></td>
							<td>
								Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep when given the -E option in POSIX.<br>
								<ins>
								If this flag is passed to an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, or <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><code>multiline</code></td>
							<td>
								Specifies that <code>^</code> shall match the beginning of a line and <code>$</code> shall match the end of a line, if the <code>ECMAScript</code><ins> or <code>ECMAScript2019</code></ins> engine is selected.
							</td>
						</tr>
						<tr>
							<td><ins><code>ECMAScript2019</code></ins></td>
							<td>
								<ins>
								Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262 2019 or later, as modified in 30.14.<br>
								See also: ECMA-262 2019 21.2<br>
								If this flag is passed to an instance of <code>basic_regex</code> other than <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, and <code>basic_regex&lt;char32_t&gt;</code>, it shall be interpreted as if no grammar element is set.
								</ins>
							</td>
						</tr>
						<tr>
							<td><ins><code>dotall</code></ins></td>
							<td>
								<ins>
								Specifies that <code>.</code> shall match any code point including new-line characters, if the <code>ECMAScript2019</code> engine is selected.
								</ins>
							</td>
						</tr>
					</table>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.5.2 Bitmask type <code>match_flag_type</code> [re.matchflag]
				</h4>

				<div class="changes">
					<table class="defstyle" id="table125">
						<caption>Table 125: <code>regex_constants::match_flag_type</code> effects when obtaining a match against a character container sequence <code>[first, last)</code>. [tab:re.matchflag]</caption>
						<tr>
							<th>Element</th>
							<th>Effect(s) if set</th>
						</tr>
						<tr>
							<td><code>...</code></td>
							<td>
								...
							</td>
						</tr>
						<tr>
							<td><code>format_default</code></td>
							<td>When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the ECMAScript replace function in ECMA-262<ins> third edition</ins>, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all non-overlapping occurrences of the regular expression shall be located and replaced, and sections of the input that did not match the expression shall be copied unchanged to the output string.
							</td>
						</tr>
					</table>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.8 Class template <code>basic_regex</code> [re.regex]
				</h4>
				<div class="changes">
					<h4>
						<ins>
						30.8.7 <code>basic_regex</code> specializations [re.regex.special]
						</ins>
					</h4>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						The header &lt;regex&gt; defines three specializations of the class template <code>basic_regex</code>: <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, and <code>basic_regex&lt;char32_t&gt;</code>.
						</ins>
						</p>
						<p>
						<ins>
						<span class="num">2</span>
						[<i>Note</i>:
						These specializations are not required necessarily to be implemented separately; typical implementations will use an internal iterator class template that has specializations for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code> to translate an input sequence of UTF-8, UTF-16, and UTF-32 respectively to a sequence of Unicode code points, and construct a finite state machine by parsing that translated sequence in a base class shared by these three specializations.
						—<i>end note</i>]
						</ins>
						</p>
						<p>
						<ins>
						<span class="num">3</span>
						These specializations shall not use <code>regex_traits</code> to construct a internal finite state machine. [<i>Note</i>: Particularly, case folding, translating a character prior to comparison without regard to case, shall be performed as defined in ECMA-262 2019 or later, and shall not be performed as defined in <code>traits::translate_nocase(c)</code>. —<i>end note</i>]
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.1 class <code>basic_regex&lt;char8_t&gt;</code> specializations [re.regex.special.char8_t]
					</ins>
					</h4>
					<div class="indent">
						<p class="code novm">
						<ins>
						namespace std {<br>
						&nbsp;&nbsp;template&lt;&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;class basic_regex&lt;char8_t&gt; {<br>
						&nbsp;&nbsp;&nbsp;&nbsp;public:
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// types</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using value_type = char8_t;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using traits_type = void;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using string_type = basic_string&lt;char8_t&gt;;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using flag_type = regex_constants::syntax_option_type;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using locale_type = locale;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.5.1, constants</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type icase = regex_constants::icase;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type nosubs = regex_constants::nosubs;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type optimize = regex_constants::optimize;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type multiline = regex_constants::multiline;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type ECMAScript2019 = regex_constants::ECMAScript2019;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type dotall = regex_constants::dotall;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.8.7.1.1, construct/copy/destroy</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex();<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit basic_regex(const char8_t* p, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(const char8_t* p, size_t len, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(const basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(basic_regex&amp;&amp;) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ST, class SA&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit basic_regex(const basic_string&lt;char8_t, ST, SA&gt;&amp; p,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ForwardIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(ForwardIterator first, ForwardIterator last,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(initializer_list&lt;char8_t&gt;, flag_type = regex_constants::ECMAScript2019);
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;~basic_regex();
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(basic_regex&amp;&amp;) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const char8_t* ptr);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(initializer_list&lt;char8_t&gt; il);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ST, class SA&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const basic_string&lt;char8_t, ST, SA&gt;&amp; p);
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.8.7.1.2, assign</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const basic_regex&amp; that);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(basic_regex&amp;&amp; that) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const char8_t* ptr, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const char8_t* p, size_t len, flag_type f);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class string_traits, class A&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const basic_string&lt;char8_t, string_traits, A&gt;&amp; s,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class InputIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(InputIterator first, InputIterator last,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(initializer_list&lt;char8_t&gt;,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type = regex_constants::ECMAScript2019);
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.8.7.1.3, const operations</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned mark_count() const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const char8_t* p) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const char8_t* p, size_t len) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class string_traits, class A&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const basic_string&lt;char8_t, string_traits, A&gt;&amp; s) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class InputIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(InputIterator first, InputIterator last) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type flags() const;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.8.7.1.4, locale</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;locale_type imbue(locale_type loc);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;locale_type getloc() const;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.8.7.1.5, swap</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;void swap(basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;};
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.1.1 Constructors [re.regex.special.char8_t.construct]
					</ins>
					</h4>

					<p class="code">
					<ins>
					basic_regex();
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						<i>Effects:</i> Constructs an object of class <code>basic_regex</code> that does not match any character sequence.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					explicit basic_regex(const char8_t* p, flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">2</span>
						<i>Requires:</i> <code>p</code> shall not be a null pointer.<br>
						<span class="num">3</span>
						<i>Throws:</i> <code>regex_error</code> if <code>p</code> is not a valid regular expression.<br>
						<span class="num">4</span>
						<i>Effects:</i> Constructs an object of class <code>basic_regex</code>; the object’s internal finite state machine is constructed from the regular expression contained in the array of <code>char8_t</code> of length <code>char_traits&lt;char8_t&gt;::length(p)</code> whose first element is designated by <code>p</code> and whose elements represent a UTF-8 sequence, and interpreted according to the flags <code>f</code>.<br>
						<span class="num">5</span>
						<i>Ensures:</i> <code>flags()</code> returns <code>f</code>. <code>mark_count()</code> returns the number of marked sub-expressions within the expression.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex(const char8_t* p, size_t len, flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">6</span>
						<i>Requires:</i> <code>p</code> shall not be a null pointer.<br>
						<span class="num">7</span>
						<i>Throws:</i> <code>regex_error</code> if <code>p</code> is not a valid regular expression.<br>
						<span class="num">8</span>
						<i>Effects:</i> Constructs an object of class <code>basic_regex</code>; the object’s internal finite state machine is constructed from the regular expression contained in the sequence of UTF-8 code units <code>[p, p+len)</code>, and interpreted according the flags specified in <code>f</code>.<br>
						<span class="num">9</span>
						<i>Ensures:</i> <code>flags()</code> returns <code>f</code>. <code>mark_count()</code> returns the number of marked sub-expressions within the expression.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex(const basic_regex&amp; e);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">10</span>
						<i>Effects:</i> Constructs an object of class <code>basic_regex</code> as a copy of the object <code>e</code>.<br>
						<span class="num">11</span>
						<i>Ensures:</i> <code>flags()</code> and <code>mark_count()</code> return <code>e.flags()</code> and <code>e.mark_count()</code>, respectively.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex(basic_regex&amp;&amp; e) noexcept;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">12</span>
						<i>Effects:</i> Move constructs an object of class <code>basic_regex</code> from <code>e</code>.<br>
						<span class="num">13</span>
						<i>Ensures:</i> <code>flags()</code> and <code>mark_count()</code> return the values that <code>e.flags()</code> and <code>e.mark_count()</code>, respectively, had before construction. <code>e</code> is in a valid state with unspecified value.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class ST, class SA&gt;<br>
					&nbsp;&nbsp;explicit basic_regex(const basic_string&lt;char8_t, ST, SA&gt;&amp; s,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">14</span>
						<i>Throws:</i> <code>regex_error</code> if <code>s</code> is not a valid regular expression.<br>
						<span class="num">15</span>
						<i>Effects:</i> Constructs an object of class <code>basic_regex</code>; the object’s internal finite state machine is constructed from the regular expression contained in the string <code>s</code> whose elements represent a UTF-8 sequence, and interpreted according to the flags specified in <code>f</code>.<br>
						<span class="num">16</span>
						<i>Ensures:</i> <code>flags()</code> returns <code>f</code>. <code>mark_count()</code> returns the number of marked sub-expressions within the expression.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class ForwardIterator&gt;<br>
					&nbsp;&nbsp;basic_regex(ForwardIterator first, ForwardIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">17</span>
						<i>Throws:</i> <code>regex_error</code> if the sequence <code>[first, last)</code> is not a valid regular expression.<br>
						<span class="num">18</span>
						<i>Effects:</i> Constructs an object of class <code>basic_regex</code>; the object’s internal finite state machine is constructed from the regular expression contained in the sequence of UTF-8 code units <code>[first, last)</code>, and interpreted according to the flags specified in <code>f</code>.<br>
						<span class="num">19</span>
						<i>Ensures:</i> <code>flags()</code> returns <code>f</code>. <code>mark_count()</code> returns the number of marked sub-expressions within the expression.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex(initializer_list&lt;charT&gt; il, flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">20</span>
						<i>Effects:</i> Same as <code>basic_regex(il.begin(), il.end(), f)</code>.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.1.2 Assignment [re.regex.special.char8_t.assign]
					</ins>
					</h4>

					<p class="code">
					<ins>
					basic_regex&amp; operator=(const basic_regex&amp; e);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						<i>Effects:</i> Copies <code>e</code> into <code>*this</code> and returns <code>*this</code>.<br>
						<span class="num">2</span>
						<i>Ensures:</i> <code>flags()</code> and <code>mark_count()</code> return <code>e.flags()</code> and <code>e.mark_count()</code>, respectively.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex&amp; operator=(basic_regex&amp;&amp; e) noexcept;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">3</span>
						<i>Effects:</i> Move assigns from <code>e</code> into <code>*this</code> and returns <code>*this</code>.<br>
						<span class="num">4</span>
						<i>Ensures:</i> <code>flags()</code> and <code>mark_count()</code> return the values that <code>e.flags()</code> and <code>e.mark_count()</code>, respectively, had before assignment. <code>e</code> is in a valid state with unspecified value.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex&amp; operator=(const charT* ptr);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">5</span>
						<i>Requires:</i> <code>ptr</code> shall not be a null pointer.<br>
						<span class="num">6</span>
						<i>Effects:</i> Returns <code>assign(ptr)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex&amp; operator=(initializer_list&lt;charT&gt; il);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">7</span>
						<i>Effects:</i> Returns <code>assign(il.begin(), il.end())</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class ST, class SA&gt;<br>
					&nbsp;&nbsp;basic_regex&amp; operator=(const basic_string&lt;charT, ST, SA&gt;&amp; p);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">8</span>
						<i>Effects:</i> Returns <code>assign(p)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex&amp; assign(const basic_regex&amp; that);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">9</span>
						<i>Effects:</i> Equivalent to: <code>return *this = that;</code>
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex& assign(basic_regex&& that) noexcept;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">10</span>
						<i>Effects:</i> Equivalent to: <code>return *this = std::move(that);</code>
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">11</span>
						<i>Returns:</i> <code>assign(string_type(ptr), f)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex& assign(const charT* ptr, size_t len, flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">12</span>
						<i>Returns:</i> <code>assign(string_type(ptr, len), f)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class string_traits, class A&gt;<br>
					&nbsp;&nbsp;basic_regex& assign(const basic_string&lt;charT, string_traits, A&gt;& s,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">13</span>
						<i>Throws:</i> <code>regex_error</code> if <code>s</code> is not a valid regular expression.<br>
						<span class="num">14</span>
						<i>Returns:</i> <code>*this</code>.<br>
						<span class="num">15</span>
						<i>Effects:</i> Assigns the regular expression contained in the string <code>s</code> whose elements represent a UTF-8 sequence, interpreted according the flags specified in <code>f</code>. If an exception is thrown, <code>*this</code> is unchanged.<br>
						<span class="num">16</span>
						<i>Ensures:</i> If no exception is thrown, <code>flags()</code> returns <code>f</code> and <code>mark_count()</code> returns the number of marked sub-expressions within the expression.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class InputIterator&gt;<br>
					&nbsp;&nbsp;basic_regex& assign(InputIterator first, InputIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">17</span>
						<i>Requires:</i> <code>InputIterator</code> shall meet the <i>Cpp17InputIterator</i> requirements (23.3.5.2).<br>
						<span class="num">18</span>
						<i>Returns:</i> <code>assign(string_type(first, last), f)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					basic_regex& assign(initializer_list&lt;charT&gt; il,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">19</span>
						<i>Effects:</i> Same as <code>assign(il.begin(), il.end(), f)</code>.<br>
						<span class="num">20</span>
						<i>Returns:</i> <code>*this</code>.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.1.3 Constant operations [re.regex.special.char8_t.operations]
					</ins>
					</h4>

					<p class="code">
					<ins>
					unsigned mark_count() const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						<i>Effects:</i> Returns the number of marked sub-expressions within the regular expression.
						</ins>
						</p>
					</div>



					<p class="code">
					<ins>
					unsigned gname_to_gnumber(const char8_t* p) const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">2</span>
						<i>Returns:</i> <code>gname_to_gnumber(string_type(p))</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					unsigned gname_to_gnumber(const char8_t* p, size_t len) const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">3</span>
						<i>Returns:</i> <code>gname_to_gnumber(string_type(p, len))</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class string_traits, class A&gt;<br>
					&nbsp;&nbsp;unsigned gname_to_gnumber(const basic_string&lt;char8_t, string_traits, A&gt;&amp; s) const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">4</span>
						<i>Throws:</i> <code>error_backref</code> if <code>s</code> is an empty string or the marked sub-expression assigned with the group name being identical to the UTF-8 string <code>s</code> does not exist within the regular expression.<br>
						<span class="num">5</span>
						<i>Effects:</i> Returns the group number of the marked sub-expression assigned with the group name being identical to the UTF-8 string <code>s</code>, within the regular expression.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class InputIterator&gt;<br>
					&nbsp;&nbsp;unsigned gname_to_gnumber(InputIterator first, InputIterator last) const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">6</span>
						<i>Requires:</i> <code>InputIterator</code> shall meet the <i>Cpp17InputIterator</i> requirements (23.3.5.2).<br>
						<span class="num">7</span>
						<i>Returns:</i> <code>gname_to_gnumber(string_type(first, last))</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					flag_type flags() const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">8</span>
						<i>Effects:</i> Returns a copy of the regular expression syntax flags that were passed to the object’s constructor or to the last call to <code>assign</code>.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.1.4 Locale [re.regex.special.char8_t.locale]
					</ins>
					</h4>

					<p class="code">
					<ins>
					locale_type imbue(locale_type loc);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						<i>Returns:</i> <code>locale_type()</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					locale_type getloc() const;
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">2</span>
						<i>Returns:</i> <code>locale_type()</code>.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.1.5 Swap [re.regex.special.char8_t.swap]
					</ins>
					</h4>

					<p class="code">
					<ins>
					void swap(basic_regex& e);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						<i>Effects:</i> Swaps the contents of the two regular expressions.<br>
						<span class="num">2</span>
						<i>Ensures:</i> <code>*this</code> contains the regular expression that was in <code>e</code>, <code>e</code> contains the regular expression that was in <code>*this</code>.<br>
						<span class="num">3</span>
						<i>Complexity:</i> Constant time.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.8.7.2 class <code>basic_regex&lt;char16_t&gt;</code> specializations [re.regex.special.char16_t]
					</ins>
					</h4>
					<div class="indent">
						<p class="code novm">
						<ins>
						namespace std {<br>
						&nbsp;&nbsp;template&lt;&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;class basic_regex&lt;char16_t&gt; {<br>
						&nbsp;&nbsp;&nbsp;&nbsp;public:
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// types</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using value_type = char16_t;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using traits_type = void;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using string_type = basic_string&lt;char16_t&gt;;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using flag_type = regex_constants::syntax_option_type;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using locale_type = locale;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.5.1, constants</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type icase = regex_constants::icase;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type nosubs = regex_constants::nosubs;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type optimize = regex_constants::optimize;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type multiline = regex_constants::multiline;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type ECMAScript2019 = regex_constants::ECMAScript2019;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type dotall = regex_constants::dotall;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.2.1, -->construct/copy/destroy</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex();<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit basic_regex(const char16_t* p, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(const char16_t* p, size_t len, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(const basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(basic_regex&amp;&amp;) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ST, class SA&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit basic_regex(const basic_string&lt;char16_t, ST, SA&gt;&amp; p,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ForwardIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(ForwardIterator first, ForwardIterator last,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(initializer_list&lt;char16_t&gt;, flag_type = regex_constants::ECMAScript2019);
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;~basic_regex();
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(basic_regex&amp;&amp;) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const char16_t* ptr);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(initializer_list&lt;char16_t&gt; il);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ST, class SA&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const basic_string&lt;char16_t, ST, SA&gt;&amp; p);
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.2.2, -->assign</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const basic_regex&amp; that);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(basic_regex&amp;&amp; that) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const char16_t* ptr, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const char16_t* p, size_t len, flag_type f);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class string_traits, class A&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const basic_string&lt;char16_t, string_traits, A&gt;&amp; s,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class InputIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(InputIterator first, InputIterator last,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(initializer_list&lt;char16_t&gt;,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type = regex_constants::ECMAScript2019);
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.2.3, -->const operations</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned mark_count() const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const char16_t* p) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const char16_t* p, size_t len) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class string_traits, class A&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const basic_string&lt;char16_t, string_traits, A&gt;&amp; s) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class InputIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(InputIterator first, InputIterator last) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type flags() const;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.2.4, -->locale</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;locale_type imbue(locale_type loc);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;locale_type getloc() const;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.2.5, -->swap</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;void swap(basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;};
						</ins>
						</p>
					</div>

					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						Same as the specification of class <code>basic_regex&lt;char8_t&gt;</code> specialization, except that the words <code>char8_t</code> and UTF-8 that appear in the text are replaced with <code>char16_t</code> and UTF-16, respectively.
						</ins>
						</p>
					</div>
					<p>
					If saying "Same as the specification of ..." is not appropriate, the previous subclause will be rewritten like [re.regex.special.char8_t].
					</p>

					<h4>
					<ins>
					30.8.7.3 class <code>basic_regex&lt;char16_t&gt;</code> specializations [re.regex.special.char32_t]
					</ins>
					</h4>
					<div class="indent">
						<p class="code novm">
						<ins>
						namespace std {<br>
						&nbsp;&nbsp;template&lt;&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;class basic_regex&lt;char32_t&gt; {<br>
						&nbsp;&nbsp;&nbsp;&nbsp;public:
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// types</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using value_type = char32_t;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using traits_type = void;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using string_type = basic_string&lt;char32_t&gt;;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using flag_type = regex_constants::syntax_option_type;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;using locale_type = locale;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// 30.5.1, constants</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type icase = regex_constants::icase;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type nosubs = regex_constants::nosubs;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type optimize = regex_constants::optimize;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type multiline = regex_constants::multiline;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type ECMAScript2019 = regex_constants::ECMAScript2019;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;static constexpr flag_type dotall = regex_constants::dotall;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.3.1, -->construct/copy/destroy</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex();<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit basic_regex(const char32_t* p, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(const char32_t* p, size_t len, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(const basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(basic_regex&amp;&amp;) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ST, class SA&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit basic_regex(const basic_string&lt;char32_t, ST, SA&gt;&amp; p,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ForwardIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(ForwardIterator first, ForwardIterator last,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex(initializer_list&lt;char32_t&gt;, flag_type = regex_constants::ECMAScript2019);
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;~basic_regex();
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(basic_regex&amp;&amp;) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const char32_t* ptr);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(initializer_list&lt;char32_t&gt; il);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class ST, class SA&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; operator=(const basic_string&lt;char32_t, ST, SA&gt;&amp; p);
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.3.2, -->assign</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const basic_regex&amp; that);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(basic_regex&amp;&amp; that) noexcept;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const char32_t* ptr, flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const char32_t* p, size_t len, flag_type f);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class string_traits, class A&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(const basic_string&lt;char32_t, string_traits, A&gt;&amp; s,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class InputIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(InputIterator first, InputIterator last,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type f = regex_constants::ECMAScript2019);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;basic_regex&amp; assign(initializer_list&lt;char32_t&gt;,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type = regex_constants::ECMAScript2019);
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.3.3, -->const operations</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned mark_count() const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const char32_t* p) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const char32_t* p, size_t len) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class string_traits, class A&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(const basic_string&lt;char32_t, string_traits, A&gt;&amp; s) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;template&lt;class InputIterator&gt;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;unsigned gname_to_gnumber(InputIterator first, InputIterator last) const;<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flag_type flags() const;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.3.4, -->locale</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;locale_type imbue(locale_type loc);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;locale_type getloc() const;
						</ins>
						</p>
						<p class="novm">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>// <!-- 30.8.7.3.5, -->swap</i>
						</ins>
						</p>
						<p class="code padb">
						<ins>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;void swap(basic_regex&amp;);<br>
						&nbsp;&nbsp;&nbsp;&nbsp;};
						</ins>
						</p>
					</div>

					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						Same as the specification of class <code>basic_regex&lt;char8_t&gt;</code> specialization, except that the words <code>char8_t</code> and UTF-8 that appear in the text are replaced with <code>char32_t</code> and UTF-32, respectively.
						</ins>
						</p>
					</div>
					<p>
					If saying "Same as the specification of ..." is not appropriate, the previous subclause will be rewritten like [re.regex.special.char8_t].
					</p>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.11.2 <code>regex_match</code> [re.alg.match]
				</h4>
				<p>
				Addition of variants that take three bidirectional iterators also to non-specialized <code>regex_match</code> is for consistency and by analogy to <code>regex_search</code>.
				</p>
				<div class="changes">
					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">9</span>
						<i>Returns:</i> <code>regex_match(first, last, m, e, flags)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">10</span>
						<i>Returns:</i> <code>regex_match(first, last, e, flags)</code>.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.11.2.1 <code>regex_match</code> specializations [re.alg.match.special]
					</ins>
					</h4>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						The header &lt;regex&gt; defines three specializations of the function template <code>regex_match</code> that take as one of parameters an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, and <code>basic_regex&lt;char32_t&gt;</code>.
						</ins>
						</p>

						<p>
						<ins>
						<span class="num">2</span>
						[<i>Note</i>:
						These specializations are not required necessarily to be implemented separately; typical implementations will use an internal iterator class template that has specializations for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code> to translate an input sequence of UTF-8, UTF-16, and UTF-32 respectively to a sequence of Unicode code points, and compare that translated sequence with the passed finite state machine in a base function shared by these three specializations.
						—<i>end note</i>]
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">3</span>
						<i>Requires:</i> The type <code>BidirectionalIterator</code> shall meet the <i>Cpp17BidirectionalIterator</i> requirements (23.3.5.5).<br>
						<span class="num">4</span>
						<i>Effects:</i> Determines whether there is a match between the regular expression <code>e</code>, and all of the UTF-8 sequence <code>[first, last)</code>. The iterator <code>lookbehindlimit</code> is used to specify the limit until where reading the UTF-8 sequence backwards can be performed. If <code>first != lookbehindlimit</code> then <code>^</code> shall match <code>lookbehindlimit</code> instead of <code>first</code>. The parameter <code>flags</code> is used to control how the expression is matched against the UTF-8 sequence. When determining if there is a match, only potential matches that match the entire UTF-8 sequence are considered. Returns <code>true</code> if such a match exists, <code>false</code> otherwise.<br>
						<span class="num">5</span>
						<i> Ensures:</i> <code>m.ready() == true</code> in all cases. If the function returns <code>false</code>, then the effect on parameter <code>m</code> is unspecified except that <code>m.size()</code> returns <code>0</code> and <code>m.empty()</code> returns <code>true</code>. Otherwise the effects on parameter <code>m</code> are given in Table 129.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">6</span>
						<i>Returns:</i> <code>regex_match(first, last, first, m, e, flags)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">7</span>
						<i>Requires:</i> The type <code>BidirectionalIterator</code> shall meet the <i>Cpp17BidirectionalIterator</i> requirements (23.3.5.5).<br>
						<span class="num">8</span>
						<i>Effects:</i> Determines whether there is a match between the regular expression <code>e</code>, and all of the UTF-16 sequence <code>[first, last)</code>. The iterator <code>lookbehindlimit</code> is used to specify the limit until where reading the UTF-16 sequence backwards can be performed. If <code>first != lookbehindlimit</code> then <code>^</code> shall match <code>lookbehindlimit</code> instead of <code>first</code>. The parameter <code>flags</code> is used to control how the expression is matched against the UTF-16 sequence. When determining if there is a match, only potential matches that match the entire UTF-16 sequence are considered. Returns <code>true</code> if such a match exists, <code>false</code> otherwise.<br>
						<span class="num">9</span>
						<i> Ensures:</i> <code>m.ready() == true</code> in all cases. If the function returns <code>false</code>, then the effect on parameter <code>m</code> is unspecified except that <code>m.size()</code> returns <code>0</code> and <code>m.empty()</code> returns <code>true</code>. Otherwise the effects on parameter <code>m</code> are given in Table 129.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">10</span>
						<i>Returns:</i> <code>regex_match(first, last, first, m, e, flags)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">11</span>
						<i>Requires:</i> The type <code>BidirectionalIterator</code> shall meet the <i>Cpp17BidirectionalIterator</i> requirements (23.3.5.5).<br>
						<span class="num">12</span>
						<i>Effects:</i> Determines whether there is a match between the regular expression <code>e</code>, and all of the UTF-32 sequence <code>[first, last)</code>. The iterator <code>lookbehindlimit</code> is used to specify the limit until where reading the UTF-32 sequence backwards can be performed. If <code>first != lookbehindlimit</code> then <code>^</code> shall match <code>lookbehindlimit</code> instead of <code>first</code>. The parameter <code>flags</code> is used to control how the expression is matched against the UTF-32 sequence. When determining if there is a match, only potential matches that match the entire UTF-32 sequence are considered. Returns <code>true</code> if such a match exists, <code>false</code> otherwise.<br>
						<span class="num">13</span>
						<i> Ensures:</i> <code>m.ready() == true</code> in all cases. If the function returns <code>false</code>, then the effect on parameter <code>m</code> is unspecified except that <code>m.size()</code> returns <code>0</code> and <code>m.empty()</code> returns <code>true</code>. Otherwise the effects on parameter <code>m</code> are given in Table 129.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_match(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">14</span>
						<i>Returns:</i> <code>regex_match(first, last, first, m, e, flags)</code>.
						</ins>
						</p>
					</div>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.11.3 <code>regex_search</code> [re.alg.search]
				</h4>
				<p>
				Addition of variants that take three bidirectional iterators also to non-specialized <code>regex_search</code> is for <code>regex_itertor</code> and consistency.
				</p>
				<div class="changes">
					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;&amp; e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">9</span>
						<i>Returns:</i> <code>regex_search(first, last, m, e, flags)</code>.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator, class charT, class traits&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;charT, traits&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">10</span>
						<i>Returns:</i> <code>regex_search(first, last, e, flags)</code>.
						</ins>
						</p>
					</div>

					<h4>
					<ins>
					30.11.3.1 <code>regex_search</code> specializations [re.alg.search.special]
					</ins>
					</h4>
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						The header &lt;regex&gt; defines three specializations of the function template <code>regex_search</code> that take as one of parameters an instance of <code>basic_regex&lt;char8_t&gt;</code>, <code>basic_regex&lt;char16_t&gt;</code>, and <code>basic_regex&lt;char32_t&gt;</code>.
						</ins>
						</p>

						<p>
						<ins>
						<span class="num">2</span>
						[<i>Note</i>:
						These specializations are not required necessarily to be implemented separately; typical implementations will use an internal iterator class template that has specializations for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code> to translate an input sequence of UTF-8, UTF-16, and UTF-32 respectively to a sequence of Unicode code points, and compare that translated sequence with the passed finite state machine in a base function shared by these three specializations.
						—<i>end note</i>]
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">3</span>
						<i>Requires:</i> Type <code>BidirectionalIterator</code> shall meet the <i>Cpp17BidirectionalIterator</i> requirements (23.3.5.5).<br>
						<span class="num">4</span>
						<i>Effects:</i> Determines whether there is some sub-sequence within the UTF-8 sequence <code>[first, last)</code> that matches the regular expression <code>e</code>. The iterator <code>lookbehindlimit</code> is used to specify the limit until where reading the UTF-8 sequence backwards can be performed. If <code>first != lookbehindlimit</code> then <code>^</code> shall match <code>lookbehindlimit</code> instead of <code>first</code>. The parameter <code>flags</code> is used to control how the expression is matched against the UTF-8 sequence. Returns <code>true</code> if such a sequence exists, <code>false</code> otherwise.<br>
						<span class="num">5</span>
						<i>Ensures:</i> <code>m.ready() == true</code> in all cases. If the function returns <code>false</code>, then the effect on parameter <code>m</code> is unspecified except that <code>m.size()</code> returns <code>0</code> and <code>m.empty()</code> returns <code>true</code>. Otherwise the effects on parameter <code>m</code> are given in Table 130.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char8_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">6</span>
						<i>Returns:</i> <code>regex_search(first, last, first, m, e, flags)</code>.
						</ins>
						<p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">7</span>
						<i>Requires:</i> Type <code>BidirectionalIterator</code> shall meet the <i>Cpp17BidirectionalIterator</i> requirements (23.3.5.5).<br>
						<span class="num">8</span>
						<i>Effects:</i> Determines whether there is some sub-sequence within the UTF-16 sequence <code>[first, last)</code> that matches the regular expression <code>e</code>. The iterator <code>lookbehindlimit</code> is used to specify the limit until where reading the UTF-16 sequence backwards can be performed. If <code>first != lookbehindlimit</code> then <code>^</code> shall match <code>lookbehindlimit</code> instead of <code>first</code>. The parameter <code>flags</code> is used to control how the expression is matched against the UTF-16 sequence. Returns <code>true</code> if such a sequence exists, <code>false</code> otherwise.<br>
						<span class="num">9</span>
						<i>Ensures:</i> <code>m.ready() == true</code> in all cases. If the function returns <code>false</code>, then the effect on parameter <code>m</code> is unspecified except that <code>m.size()</code> returns <code>0</code> and <code>m.empty()</code> returns <code>true</code>. Otherwise the effects on parameter <code>m</code> are given in Table 130.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char16_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">10</span>
						<i>Returns:</i> <code>regex_search(first, last, first, m, e, flags)</code>.
						</ins>
						<p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BidirectionalIterator lookbehindlimit,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">11</span>
						<i>Requires:</i> Type <code>BidirectionalIterator</code> shall meet the <i>Cpp17BidirectionalIterator</i> requirements (23.3.5.5).<br>
						<span class="num">12</span>
						<i>Effects:</i> Determines whether there is some sub-sequence within the UTF-32 sequence <code>[first, last)</code> that matches the regular expression <code>e</code>. The iterator <code>lookbehindlimit</code> is used to specify the limit until where reading the UTF-32 sequence backwards can be performed. If <code>first != lookbehindlimit</code> then <code>^</code> shall match <code>lookbehindlimit</code> instead of <code>first</code>. The parameter <code>flags</code> is used to control how the expression is matched against the UTF-32 sequence. Returns <code>true</code> if such a sequence exists, <code>false</code> otherwise.<br>
						<span class="num">13</span>
						<i>Ensures:</i> <code>m.ready() == true</code> in all cases. If the function returns <code>false</code>, then the effect on parameter <code>m</code> is unspecified except that <code>m.size()</code> returns <code>0</code> and <code>m.empty()</code> returns <code>true</code>. Otherwise the effects on parameter <code>m</code> are given in Table 130.
						</ins>
						</p>
					</div>

					<p class="code">
					<ins>
					template&lt;class BidirectionalIterator, class Allocator&gt;<br>
					&nbsp;&nbsp;bool regex_search(BidirectionalIterator first, BidirectionalIterator last,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;match_results&lt;BidirectionalIterator, Allocator&gt;& m,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;const basic_regex&lt;char32_t&gt;& e,<br>
					&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;regex_constants::match_flag_type flags = regex_constants::match_default);
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						<span class="num">14</span>
						<i>Returns:</i> <code>regex_search(first, last, first, m, e, flags)</code>.
						</ins>
						<p>
					</div>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.12 Regular expression iterators [re.iter]
				</h4>
				<div class="changes">
					<h4>
					30.12.1.1 Constructors [re.regiter.cnstr]
					</h4>
					<div class="indent">
						<p>
						<span class="num">2</span>
						Effects: Initializes <code>begin</code> and <code>end</code> to <code>a</code> and <code>b</code>, respectively, sets <code>pregex</code> to <code>addressof(re)</code>, sets <code>flags</code> to <code>m</code>, then calls <code>regex_search(begin, end<ins>, <code>begin</code></ins>, match, *pregex, flags)</code>. If this call returns <code>false</code> the constructor sets <code>*this</code> to the end-of-sequence iterator.
						</p>
					</div>

					<h4>
					30.12.1.4 Increment [re.regiter.incr]
					</h4>
					<div class="indent">
						<p>
						<span class="num">3</span>
						Otherwise, if the iterator holds a zero-length match, the operator calls:<br>
						</p>
						<p class="code">
						&nbsp;&nbsp;regex_search(start, end<ins>, begin</ins>, match, *pregex,<br>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;flags | regex_constants::match_not_null | regex_constants::match_continuous)
						</p>
						<p>
						If the call returns <code>true</code> the operator returns <code>*this</code>. Otherwise the operator increments <code>start</code> and continues as if the most recent match was not a zero-length match.
						</p>
						<p>
						<span class="num">4</span>
						If the most recent match was not a zero-length match, the operator sets <code>flags</code> to <code>flags | regex_constants::match_prev_avail</code> and calls <code>regex_search(start, end<ins>, begin</ins>, match, *pregex, flags)</code>. If the call returns <code>false</code> the iterator sets <code>*this</code> to the end-of-sequence iterator. The iterator then returns <code>*this</code>.
						</p>
					</div>
				</div>
			</li>

			<li>
				<h4 class="target">
				30.13 Modified ECMAScript regular expression grammar [re.grammar]
				</h4>

				<div class="changes">
					<div class="indent">
						<p>
						<span class="num">1</span>
						The regular expression grammar recognized by <code>basic_regex</code> objects constructed with the ECMAScript flag is that specified by ECMA-262<ins> third edition</ins>, except as specified below.
						</p>
						<p>
						<span class="num">14</span>
						The behavior of the internal finite state machine representation when used to match a sequence of characters is as described in ECMA-262<ins> third edition</ins>. The behavior is modified according to any <code>match_flag_type</code> flags (30.5.2) specified when using the regular expression object in one of the regular expression algorithms (30.11). The behavior is also localized by interaction with the traits class template parameter as follows:
						</p>
					</div>
					<p>
					See also: ECMA-262<ins> third edition</ins> 15.10
					</p>
				</div>
			</li>

			<li>
				<h4 class="target changes">
				<ins>
				30.14 Modified ECMAScript2019 regular expression grammar [re.grammar2019]
				</ins>
				</h4>
				<div class="changes">
					<div class="indent">
						<p>
						<ins>
						<span class="num">1</span>
						The following production within the ECMAScript2019 grammar is modified as follows:
						</ins>
						</p>
					</div>
					<p class="code">
					<ins>
					CharacterEscape::HexEscapeSequence
					</ins>
					</p>
					<div class="indent">
						<p>
						<ins>
						Return the numeric value of the code <em class="del">unit</em><em class="ins">point</em> that is the SV of <i>HexEscapeSequence</i>.
						</ins>
						</p>
					</div>
				</div>
			</li>
		</ul>
	</section>

	<section>
		<h3>Others</h3>
		<p>
		The undated version of the ECMAScript Specification is added to references.
		</p>
		<ul class="changes">
			<li>
				<h4 class="target">
				2 Normative references [intro.refs]
				</h4>
				<div class="changes">
					<ul class="indent">
						<li>
						<ins>
						<span class="num">(1.1)</span>
						— Ecma International, ECMAScript Language Specification, Standard Ecma-262.
						</ins>
						</li>
						<li>
						<span class="num">(1.<del>1</del><ins>2</ins>)</span>
						— Ecma International, ECMAScript Language Specification, Standard Ecma-262, third edition, 1999.
						</li>
						<li>
						<span class="num">(1.<del>2</del><ins>3</ins>)</span>
						— INTERNET ENGINEERING TASK FORCE (IETF). RFC 6557: Procedures for Maintaining the Time
Zone Database [online]. Edited by E. Lear, P. Eggert. February 2012 [viewed 2018-03-26]. Available at
https://www.ietf.org/rfc/rfc6557.txt
						</li>
						<li>
						<span class="num">(1.<del>3</del><ins>4</ins>)</span>
						— ISO/IEC 2382 (all parts), Information technology — Vocabulary
						</li>
						<li>
						<span class="num">(1.<del>4</del><ins>5</ins>)</span>
						— ISO 8601:2004, Data elements and interchange formats — Information interchange — Representation of dates and times
						</li>
						<li>
						<span class="num">(1.<del>5</del><ins>6</ins>)</span>
						— ISO/IEC 9899:2011, Programming languages — C
						</li>
						<li>
						<span class="num">(1.<del>6</del><ins>7</ins>)</span>
						— ISO/IEC 9945:2003, Information Technology — Portable Operating System Interface (POSIX)
						</li>
						<li>
						<span class="num">(1.<del>7</del><ins>8</ins>)</span>
						— ISO/IEC 10646, Information technology — Universal Coded Character Set (UCS)
						</li>
						<li>
						<span class="num">(1.<del>8</del><ins>9</ins>)</span>
						— ISO/IEC 10646-1:1993, Information technology — Universal Multiple-Octet Coded Character Set (UCS)
						— Part 1: Architecture and Basic Multilingual Plane
						</li>
						<li>
						<span class="num">(1.<del>9</del><ins>10</ins>)</span>
						— ISO/IEC/IEEE 60559:2011, Information technology — Microprocessor Systems — Floating-Point arithmetic
						</li>
						<li>
						<span class="num">(1.<del>10</del><ins>11</ins>)</span>
						— ISO 80000-2:2009, Quantities and units — Part 2: Mathematical signs and symbols to be used in the natural sciences and technology
						</li>
					</ul>
				</div>
			</li>
		</ul>
	</section>
</section>

<section>
	<h2 id="sec6">VI. Relevant Matter</h2>

	<ul>
		<li>
			<p>
			The author of this document is aware of P1433 Compile Time Regular Expressions. Even in the case that any proposal based on CTRE becomes part of the C++ standard, it is envisioned that need for &lt;regex&gt; remains for situations where a sequence of regular expressions is settled at runtime.
			</p>
		</li>
	</ul>
</section>

<section>
	<h2 id="sec7">VII. References</h2>
	<ul>
		<li>Ecma International, <span class="title"><a href="http://www.ecma-international.org/ecma-262/10.0/">ECMA-262, 10th edition, June 2019 ECMAScript® 2019 Language Specification</a></span></li>
		<li>The Unicode Consortium, <span class="title">Unicode Character Database</span>, <a href="http://www.unicode.org/Public/UCD/latest/ucd/CaseFolding.txt">CaseFolding.txt</a></li>
	</ul>
</section>

<section>
	<h2 id="sec8">VIII. Appendix</h2>
	<ul>
		<li><a href="http://www.akenotsuki.com/misc/srell/en/proposal/">Sample implementation</a></li>
	</ul>
	<p>
	This example can be used with <code>char8_t</code>, <code>char16_t</code>, <code>char32_t</code> only. <code>char</code> and <code>wchar_t</code> versions are not implemented. If <code>basic_regex</code> or an algorithm function is used with a type other than <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code>, <code>assert(0)</code> is called.
	It demonstrates that adding a new syntax option for <code>char8_t</code>, <code>char16_t</code>, and <code>char32_t</code> through the template specialization is a real option.
	</p>
	<p>
	All the classes and algorithms are declared in <code>namespace regex_proposal</code>, instead of <code>std</code>.
	</p>
	<p>
	This proposal needs a presenter. If you like this proposal and can attend face-to-face committee meetings of C++, please contact me.
	</p>
</section>

</body>
</html>
