<!doctype html><html lang="en">
 <head>
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P3179R4: C++ parallel range algorithms</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in § N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *     -> ins/del.c### for candidate and proposed changes (amendments)
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *   - .correction for "candidate corrections"       (div, aside, details, section)
 *   - .addition   for "candidate additions"         (div, aside, details, section)
 *   - .correction.proposed for "proposed corrections" (div, aside, details, section)
 *   - .addition.proposed   for "proposed additions"   (div, aside, details, section)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Outdated warning for old specs
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/* color variables included separately for reliability */

/******************************************************************************/
/*                                    Body                                    */
/******************************************************************************/

	html {
	}

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;			  /* limit line length to 50em for readability   */
		margin: 0 auto;				/* center text within page                    */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag    */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		color: black;
		color: var(--text);
		background: white top left fixed no-repeat;
		background: var(--bg) top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em; }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border: solid var(--logo-bg);
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		background: var(--logo-bg);
		color: white;
		color: var(--logo-text);
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		background: var(--logo-active-bg);
		border-color: #c00;
		border-color: var(--logo-active-bg);
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small; }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 3;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;

			color: #707070;
			color: var(--tocnav-normal-text);
			background: white;
			background: var(--tocnav-normal-bg);
		}
		#toc-nav > a:hover,
		#toc-nav > a:focus {
			color: black;
			color: var(--tocnav-hover-text);
			background: #f8f8f8;
			background: var(--tocnav-hover-bg);
		}
		#toc-nav > a:active {
			color: #c00;
			color: var(--tocnav-active-text);
			background: white;
			background: var(--tocnav-active-bg);
		}

		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
			color: var(--tocsidebar-heading-text);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
			color: var(--tocsidebar-heading-text);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;	/* Inherit the font family. */
		line-height: 1.2;		/* Keep wrapped headings compact */
		hyphens: manual;		/* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		color: var(--heading-text);
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#profile-and-date {
		/* #profile-and-date is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > :not(.head) + hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		color: black;
		color: var(--hr-text);
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	border-left: 0.5em solid #DEF;
	border-left: 0.5em solid var(--algo-border);
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	 padding: .5em;
	 border: thin solid #ddd;
	 border: thin solid var(--algo-border);
	 border-radius: .5em;
	 margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	 margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	 margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	margin-left: -2em;
	}
	dl.switch {
	padding-left: 2em;
	}
	dl.switch > dt {
	text-indent: -1.5em;
	margin-top: 1em;
	}
	dl.switch > dt + dt {
	margin-top: 0;
	}
	dl.switch > dt::before {
	content: '\21AA';
	padding: 0 0.5em 0 0;
	display: inline-block;
	width: 1em;
	text-align: right;
	line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: inherit;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del {
		color: #aa0000;
		color: var(--del-text);
		background: transparent;
		background: var(--del-bg);
		text-decoration: line-through;
	}
	ins {
		color: #006100;
		color: var(--ins-text);
		background: transparent;
		background: var(--ins-bg);
		text-decoration: underline;
	}

	/* for amendments (candidate/proposed changes) */

	.amendment ins, .correction ins, .addition ins,
	ins[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment del, .correction del, .addition del,
	del[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment.proposed ins, .correction.proposed ins, .addition.proposed ins,
	ins[class^=c].proposed {
		text-decoration-style: double;
	}
	.amendment.proposed del, .correction.proposed del, .addition.proposed del,
	del[class^=c].proposed {
		text-decoration-style: double;
	}

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		hyphens: none;
		text-transform: none;
		text-align: left;
		text-align: start;
		font-variant: normal;
		orphans: 3;
		widows: 3;
		page-break-before: avoid;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

	/* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		color: var(--a-normal-text);
		text-decoration: underline #707070;
		text-decoration: underline var(--a-normal-underline);
		text-decoration-skip-ink: none;
	}
	a:visited {
		color: #034575;
		color: var(--a-visited-text);
		text-decoration-color: #bbb;
		text-decoration-color: var(--a-visited-underline);
	}

	/* Indicate interaction with the link */
	a[href]:focus,
	a[href]:hover {
		text-decoration-thickness: 2px;
	}
	a[href]:active {
		color: #c00;
		color: var(--a-active-text);
		text-decoration-color: #c00;
		text-decoration-color: var(--a-active-underline);
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	img, svg {
		/* Intentionally not color-scheme aware. */
		background: white;
	}

	/* For autogen numbers, add
	  .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,	.sidefigure img,	figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
		height: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em;
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em; }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote,
	.amendment, .correction, .addition {
		margin: 1em auto;
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	blockquote > :first-child,
	.note  > p:first-child,
	.issue > p:first-child,
	.amendment > p:first-child,
	.correction > p:first-child,
	.addition > p:first-child {
		margin-top: 0;
	}
	blockquote > :last-child,
	.note  > p:last-child,
	.issue > p:last-child,
	.amendment > p:last-child,
	.correction > p:last-child,
	.addition > p:last-child {
		margin-bottom: 0;
	}


	.issue::before, .issue > .marker,
	.example::before, .example > .marker,
	.note::before, .note > .marker,
	details.note > summary > .marker,
	.amendment::before, .amendment > .marker,
	details.amendment > summary > .marker,
	.addition::before, .addition > .marker,
	addition.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	correction.amendment > summary > .marker
	{
		text-transform: uppercase;
		padding-right: 1em;
	}

	.example::before, .example > .marker {
		display: block;
		padding-right: 0em;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
		border-color: var(--blockquote-border);
		background: transparent;
		background: var(--blockquote-bg);
		color: currentcolor;
		color: var(--blockquote-text);
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #e05252;
		border-color: var(--issue-border);
		background: #fbe9e9;
		background: var(--issue-bg);
		color: black;
		color: var(--issue-text);
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		color: #831616;
		color: var(--issueheading-text);
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	  or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #e0cb52;
		border-color: var(--example-border);
		background: #fcfaee;
		background: var(--example-bg);
		color: black;
		color: var(--example-text);
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		color: #574b0f;
		color: var(--exampleheading-text);
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	  or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52e052;
		border-color: var(--note-border);
		background: #e9fbe9;
		background: var(--note-bg);
		color: black;
		color: var(--note-text);
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary {
		color: hsl(120, 70%, 30%);
		color: var(--noteheading-text);
	}
	/* Add .note::before { content: "Note "; } for autogen label,
	  or use class="marker" to mark up the label in source. */

	details.note[open] > summary {
		border-bottom: 1px silver solid;
		border-bottom: 1px var(--notesummary-underline) solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		border-color: var(--assertion-border);
		background: #EEE;
		background: var(--assertion-bg);
		color: black;
		color: var(--assertion-text);
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-color: var(--advisement-border);
		border-style: none solid;
		background: #fec;
		background: var(--advisement-bg);
		color: black;
		color: var(--advisement-text);
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement::before, .advisement > .marker {
		color: #b35f00;
		color: var(--advisementheading-text);
	}

/** Amendment Box *************************************************************/

	.amendment, .correction, .addition {
		border-color: #330099;
		border-color: var(--amendment-border);
		background: #F5F0FF;
		background: var(--amendment-bg);
		color: black;
		color: var(--amendment-text);
	}
	.amendment.proposed, .correction.proposed, .addition.proposed {
		border-style: solid;
		border-block-width: 0.25em;
	}
	.amendment::before, .amendment > .marker,
	details.amendment > summary::before, details.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	details.correction > summary::before, details.correction > summary > .marker,
	.addition::before, .addition > .marker,
	details.addition > summary::before, details.addition > summary > .marker {
		color: #220066;
		color: var(--amendmentheading-text);
	}
	.amendment.proposed::before, .amendment.proposed > .marker,
	details.amendment.proposed > summary::before, details.amendment.proposed > summary > .marker,
	.correction.proposed::before, .correction.proposed > .marker,
	details.correction.proposed > summary::before, details.correction.proposed > summary > .marker,
	.addition.proposed::before, .addition.proposed > .marker,
	details.addition.proposed > summary::before, details.addition.proposed > summary > .marker {
		font-weight: bold;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: hsla(40,100%,50%,0.95);
		background: var(--warning-bg);
		color: black;
		color: var(--warning-text);
		padding: .75em 1em;
		border: red;
		border: var(--warning-border);
		border-style: solid none;
		box-shadow: 0 2px 8px black;
		text-align: center;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 0;
		right: 0;
		bottom: 2em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #def;
		background: var(--def-bg);
		margin: 1.2em 0;
		border-left: 0.5em solid #8ccbf2;
		border-left: 0.5em solid var(--def-border);
		color: black;
		color: var(--def-text);
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
		border-bottom: 1px solid var(--defrow-border);
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def td.footnote {
		padding-top: 0.6em;
	}
	table.def td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		<table class="data"> highlights structural relationships in a table
		when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		Use class="complex data" for particularly complicated tables --
		(This will draw more lines: busier, but clearer.)

		Use class="long" on table cells with paragraph-like contents
		(This will adjust text alignment accordingly.)
		Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-color: var(--datacell-border);
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		border-top: 1px solid var(--datacell-border);
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		border: 1px solid var(--datacell-border);
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
		vertical-align: baseline;
		text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding: 0.1rem 1px 0;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Switch to using border-bottom for underlines */
		text-decoration: none;
		border-bottom: 1px solid;
		/* Reverse color scheme */
		color: black;
		color: var(--toclink-text);
		border-color: #3980b5;
		border-color: var(--toclink-underline);
	}
	.toc a:visited {
		color: black;
		color: var(--toclink-visited-text);
		border-color: #054572;
		border-color: var(--toclink-visited-underline);
	}
	.toc a:focus,
	.toc a:hover {
		background: rgba(75%, 75%, 75%, .25);
		background: var(--a-hover-bg);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
	}
	.toc {
		line-height: 1.1em;
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li			{ font-weight: bold;   }
	.toc > li li		 { font-weight: normal; }
	.toc > li li li	  { font-size:   95%;	}
	.toc > li li li li	{ font-size:   90%;	}
	.toc > li li li li li { font-size:   85%;	}

	/* @supports not (display:grid) { */
		.toc > li			{ margin: 1.5rem 0;	}
		.toc > li li		 { margin: 0.3rem 0;	}
		.toc > li li li	  { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}
		.toc > li li li li .secno { font-size: 85%; }
		.toc > li li li li li .secno { font-size: 100%; }

		.toc li {
			clear: both;
		}

		:not(li) > .toc			 { margin-left:  5rem; }
		.toc .secno				 { margin-left: -5rem; }
		.toc > li li li .secno	  { margin-left: -7rem; }
		.toc > li li li li .secno	{ margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc			 { margin-left:  4rem; }
			.toc .secno				 { margin-left: -4rem; }
			.toc > li li li			 { margin-left:  1rem; }
			.toc > li li li .secno	  { margin-left: -5rem; }
			.toc > li li li li .secno	{ margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
		/* Loosen it on wide screens */
		@media screen and (min-width: 78em) {
			body:not(.toc-inline) :not(li) > .toc			 { margin-left:  4rem; }
			body:not(.toc-inline) .toc .secno				 { margin-left: -4rem; }
			body:not(.toc-inline) .toc > li li li			 { margin-left:  1rem; }
			body:not(.toc-inline) .toc > li li li .secno	  { margin-left: -5rem; }
			body:not(.toc-inline) .toc > li li li li .secno	{ margin-left: -6rem; }
			body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
	}
	/* } */

	@supports (display:grid) and (display:contents) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			  comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
			border-bottom: 3px solid transparent;
			margin-bottom: -3px;
		}
		#toc .content:hover,
		#toc .content:focus {
			background: rgba(75%, 75%, 75%, .25);
			background: var(--a-hover-bg);
			border-bottom-color: #054572;
			border-bottom-color: var(--toclink-underline);
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index	  { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li	{ margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em; }
	ul.index dl	{ margin-top: 0; }
	ul.index dt	{ margin: .2em 0 .2em 20px;}
	ul.index dd	{ margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li a + span {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
			color: var(--indexinfo-text);
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		color: black;
		color: var(--indextable-hover-text);
		background: #f7f8f9;
		background: var(--indextable-hover-bg);
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/** Outdated warning **********************************************************/

.outdated-spec {
	color: black;
	color: var(--outdatedspec-text);
	background-color: rgba(0,0,0,0.5);
	background-color: var(--outdatedspec-bg);
}

.outdated-warning {
	position: fixed;
	bottom: 50%;
	left: 0;
	right: 0;
	margin: 0 auto;
	width: 50%;
	background: maroon;
	background: var(--outdated-bg);
	color: white;
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	position: absolute;
	top: 0;
	right:0;
	margin: 0;
	border: 0;
	padding: 0.25em 0.5em;
	background: transparent;
	color: white;
	color: var(--outdated-text);
	font:1em sans-serif;
	text-align:center;
}

.outdated-warning span {
	display: block;
}

.outdated-collapsed {
	bottom: 0;
	border-radius: 0;
	width: 100%;
	padding: 0;
}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}

		.outdated-warning {
			position: absolute;
			border-style: solid;
			border-color: red;
		}

		.outdated-warning input {
			display: none;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge {
		/* Magic to create good item positioning:
		  "content column" is 50ems wide at max; less on smaller screens.
		  Extra space (after ToC + content) is empty on the right.

		  1. When item < content column, centers item in column.
		  2. When content < item < available, left-aligns.
		  3. When item > available, fills available + scroll bar.
		*/
		display: grid;
		grid-template-columns: minmax(0, 50em);
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			* http://lea.verou.me/2012/04/background-attachment-local/
			*
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
						top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
						top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
						top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
						white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style>
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version 6270e4735, updated Tue Aug 6 12:12:30 2024 -0700" name="generator">
  <link href="https://wg21.link/P3179R4" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="5d34dc21fd3c07f862d810e2bbc694bc97ee7fa0" name="revision">
  <meta content="dark light" name="color-scheme">
<style>
    table, th, td {
        border: 1px solid black;
}

.ins, ins, ins * {
    background-color: rgb(200, 250, 200);
    color: rgb(0, 136, 0);
    text-decoration: none;
}

span, span * {
    white-space: pre;
}

.wordingStyle
{
  width: min-content
}
</style>
<style>/* Boilerplate: style-autolinks */
.css.css, .property.property, .descriptor.descriptor {
    color: var(--a-normal-text);
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}

@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}
</style>
<style>/* Boilerplate: style-colors */
/* Any --*-text not paired with a --*-bg is assumed to have a transparent bg */
:root {
    color-scheme: light dark;

    --text: black;
    --bg: white;

    --unofficial-watermark: url(https://www.w3.org/StyleSheets/TR/2016/logos/UD-watermark);

    --logo-bg: #1a5e9a;
    --logo-active-bg: #c00;
    --logo-text: white;

    --tocnav-normal-text: #707070;
    --tocnav-normal-bg: var(--bg);
    --tocnav-hover-text: var(--tocnav-normal-text);
    --tocnav-hover-bg: #f8f8f8;
    --tocnav-active-text: #c00;
    --tocnav-active-bg: var(--tocnav-normal-bg);

    --tocsidebar-text: var(--text);
    --tocsidebar-bg: #f7f8f9;
    --tocsidebar-shadow: rgba(0,0,0,.1);
    --tocsidebar-heading-text: hsla(203,20%,40%,.7);

    --toclink-text: var(--text);
    --toclink-underline: #3980b5;
    --toclink-visited-text: var(--toclink-text);
    --toclink-visited-underline: #054572;

    --heading-text: #005a9c;

    --hr-text: var(--text);

    --algo-border: #def;

    --del-text: red;
    --del-bg: transparent;
    --ins-text: #080;
    --ins-bg: transparent;

    --a-normal-text: #034575;
    --a-normal-underline: #bbb;
    --a-visited-text: var(--a-normal-text);
    --a-visited-underline: #707070;
    --a-hover-bg: rgba(75%, 75%, 75%, .25);
    --a-active-text: #c00;
    --a-active-underline: #c00;

    --blockquote-border: silver;
    --blockquote-bg: transparent;
    --blockquote-text: currentcolor;

    --issue-border: #e05252;
    --issue-bg: #fbe9e9;
    --issue-text: var(--text);
    --issueheading-text: #831616;

    --example-border: #e0cb52;
    --example-bg: #fcfaee;
    --example-text: var(--text);
    --exampleheading-text: #574b0f;

    --note-border: #52e052;
    --note-bg: #e9fbe9;
    --note-text: var(--text);
    --noteheading-text: hsl(120, 70%, 30%);
    --notesummary-underline: silver;

    --assertion-border: #aaa;
    --assertion-bg: #eee;
    --assertion-text: black;

    --advisement-border: orange;
    --advisement-bg: #fec;
    --advisement-text: var(--text);
    --advisementheading-text: #b35f00;

    --warning-border: red;
    --warning-bg: hsla(40,100%,50%,0.95);
    --warning-text: var(--text);

    --amendment-border: #330099;
    --amendment-bg: #F5F0FF;
    --amendment-text: var(--text);
    --amendmentheading-text: #220066;

    --def-border: #8ccbf2;
    --def-bg: #def;
    --def-text: var(--text);
    --defrow-border: #bbd7e9;

    --datacell-border: silver;

    --indexinfo-text: #707070;

    --indextable-hover-text: black;
    --indextable-hover-bg: #f7f8f9;

    --outdatedspec-bg: rgba(0, 0, 0, .5);
    --outdatedspec-text: black;
    --outdated-bg: maroon;
    --outdated-text: white;
    --outdated-shadow: red;

    --editedrec-bg: darkorange;
}

@media (prefers-color-scheme: dark) {
    :root {
        --text: #ddd;
        --bg: black;

        --unofficial-watermark: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cg fill='%23100808' transform='translate(200 200) rotate(-45) translate(-200 -200)' stroke='%23100808' stroke-width='3'%3E%3Ctext x='50%25' y='220' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EUNOFFICIAL%3C/text%3E%3Ctext x='50%25' y='305' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EDRAFT%3C/text%3E%3C/g%3E%3C/svg%3E");

        --logo-bg: #1a5e9a;
        --logo-active-bg: #c00;
        --logo-text: white;

        --tocnav-normal-text: #999;
        --tocnav-normal-bg: var(--bg);
        --tocnav-hover-text: var(--tocnav-normal-text);
        --tocnav-hover-bg: #080808;
        --tocnav-active-text: #f44;
        --tocnav-active-bg: var(--tocnav-normal-bg);

        --tocsidebar-text: var(--text);
        --tocsidebar-bg: #080808;
        --tocsidebar-shadow: rgba(255,255,255,.1);
        --tocsidebar-heading-text: hsla(203,20%,40%,.7);

        --toclink-text: var(--text);
        --toclink-underline: #6af;
        --toclink-visited-text: var(--toclink-text);
        --toclink-visited-underline: #054572;

        --heading-text: #8af;

        --hr-text: var(--text);

        --algo-border: #456;

        --del-text: #f44;
        --del-bg: transparent;
        --ins-text: #4a4;
        --ins-bg: transparent;

        --a-normal-text: #6af;
        --a-normal-underline: #555;
        --a-visited-text: var(--a-normal-text);
        --a-visited-underline: var(--a-normal-underline);
        --a-hover-bg: rgba(25%, 25%, 25%, .2);
        --a-active-text: #f44;
        --a-active-underline: var(--a-active-text);

        --borderedblock-bg: rgba(255, 255, 255, .05);

        --blockquote-border: silver;
        --blockquote-bg: var(--borderedblock-bg);
        --blockquote-text: currentcolor;

        --issue-border: #e05252;
        --issue-bg: var(--borderedblock-bg);
        --issue-text: var(--text);
        --issueheading-text: hsl(0deg, 70%, 70%);

        --example-border: hsl(50deg, 90%, 60%);
        --example-bg: var(--borderedblock-bg);
        --example-text: var(--text);
        --exampleheading-text: hsl(50deg, 70%, 70%);

        --note-border: hsl(120deg, 100%, 35%);
        --note-bg: var(--borderedblock-bg);
        --note-text: var(--text);
        --noteheading-text: hsl(120, 70%, 70%);
        --notesummary-underline: silver;

        --assertion-border: #444;
        --assertion-bg: var(--borderedblock-bg);
        --assertion-text: var(--text);

        --advisement-border: orange;
        --advisement-bg: #222218;
        --advisement-text: var(--text);
        --advisementheading-text: #f84;

        --warning-border: red;
        --warning-bg: hsla(40,100%,20%,0.95);
        --warning-text: var(--text);

        --amendment-border: #330099;
        --amendment-bg: #080010;
        --amendment-text: var(--text);
        --amendmentheading-text: #cc00ff;

        --def-border: #8ccbf2;
        --def-bg: #080818;
        --def-text: var(--text);
        --defrow-border: #136;

        --datacell-border: silver;

        --indexinfo-text: #aaa;

        --indextable-hover-text: var(--text);
        --indextable-hover-bg: #181818;

        --outdatedspec-bg: rgba(255, 255, 255, .5);
        --outdatedspec-text: black;
        --outdated-bg: maroon;
        --outdated-text: white;
        --outdated-shadow: red;

        --editedrec-bg: darkorange;
    }
    /* In case a transparent-bg image doesn't expect to be on a dark bg,
       which is quite common in practice... */
    img { background: white; }
}
</style>
<style>/* Boilerplate: style-counters */
body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}
</style>
<style>/* Boilerplate: style-issues */
a[href].issue-return {
    float: right;
    float: inline-end;
    color: var(--issueheading-text);
    font-weight: bold;
    text-decoration: none;
}
</style>
<style>/* Boilerplate: style-md-lists */
/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}
</style>
<style>/* Boilerplate: style-selflinks */
:root {
    --selflink-text: white;
    --selflink-bg: gray;
    --selflink-hover-text: black;
}
.heading, .issue, .note, .example, li, dt {
    position: relative;
}
a.self-link {
    position: absolute;
    top: 0;
    left: calc(-1 * (3.5rem - 26px));
    width: calc(3.5rem - 26px);
    height: 2em;
    text-align: center;
    border: none;
    transition: opacity .2s;
    opacity: .5;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
.example > a.self-link,
.note > a.self-link,
.issue > a.self-link {
    /* These blocks are overflow:auto, so positioning outside
       doesn't work. */
    left: auto;
    right: 0;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: var(--selflink-bg);
    color: var(--selflink-text);
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: var(--selflink-hover-text);
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }
</style>
<style>/* Boilerplate: style-syntax-highlighting */
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }

.highlight:not(.idl) { background: rgba(0, 0, 0, .03); }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */

@media (prefers-color-scheme: dark) {
    .highlight:not(.idl) { background: rgba(255, 255, 255, .05); }

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P3179R4<br>C++ parallel range algorithms</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="profile-and-date"><span class="content">Published Proposal, <time class="dt-updated" datetime="2024-12-10">2024-12-10</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://wg21.link/P3179R4">https://wg21.link/P3179R4</a>
     <dt class="editor">Authors:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:ruslan.arutyunyan@intel.com">Ruslan Arutyunyan</a> (<span class="p-org org">Intel</span>)
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:alexey.kukanov@intel.com">Alexey Kukanov</a> (<span class="p-org org">Intel</span>)
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:brycelelbach@gmail.com">Bryce Adelstein Lelbach (he/him/his)</a> (<span class="p-org org">Nvidia</span>)
     <dt>Audience:
     <dd>LEWG
     <dt>Project:
     <dd>ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>This paper proposes adding parallel algorithms that work together with the C++ Ranges library.</p>
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#motivation"><span class="secno">1</span> <span class="content">Motivation</span></a>
    <li>
     <a href="#design_overview"><span class="secno">2</span> <span class="content">Design overview</span></a>
     <ol class="toc">
      <li>
       <a href="#design_summary"><span class="secno">2.1</span> <span class="content">Design summary</span></a>
       <ol class="toc">
        <li><a href="#design_diff_to_cpp20_ranges"><span class="secno">2.1.1</span> <span class="content">Differences to serial range algorithms</span></a>
        <li><a href="#design_diff_to_cpp17_par"><span class="secno">2.1.2</span> <span class="content">Differences to C++17 parallel algorithms</span></a>
        <li><a href="#design_other_aspects"><span class="secno">2.1.3</span> <span class="content">Other design aspects</span></a>
        <li><a href="#design_api_example"><span class="secno">2.1.4</span> <span class="content">An example of the proposed API</span></a>
       </ol>
      <li><a href="#coexistence_with_schedulers"><span class="secno">2.2</span> <span class="content">Coexistence with schedulers</span></a>
      <li><a href="#supported_policies"><span class="secno">2.3</span> <span class="content">Supported execution policies</span></a>
      <li><a href="#return_type"><span class="secno">2.4</span> <span class="content">Algorithm return types</span></a>
      <li><a href="#algorithm_func_objects"><span class="secno">2.5</span> <span class="content">Extending the overload sets of algorithm function objects</span></a>
      <li><a href="#random_access_requirement"><span class="secno">2.6</span> <span class="content">Requiring <code class="highlight"><c- n>random_access_iterator</c-></code> or <code class="highlight"><c- n>random_access_range</c-></code></span></a>
      <li><a href="#range_as_the_output"><span class="secno">2.7</span> <span class="content">Taking range as the output</span></a>
      <li><a href="#require_bounded_ranges"><span class="secno">2.8</span> <span class="content">Requiring ranges to be bounded</span></a>
      <li><a href="#callable_parameters"><span class="secno">2.9</span> <span class="content">Requirements for callable parameters</span></a>
      <li><a href="#constexpr_support"><span class="secno">2.10</span> <span class="content"><code class="highlight"><c- k>constexpr</c-></code> parallel range algorithms</span></a>
     </ol>
    <li>
     <a href="#more_examples"><span class="secno">3</span> <span class="content">More examples</span></a>
     <ol class="toc">
      <li><a href="#easy_to_switch"><span class="secno">3.1</span> <span class="content">Change existing code to use parallel range algorithms</span></a>
      <li><a href="#less_parallel_call"><span class="secno">3.2</span> <span class="content">Less parallel algorithm calls and better expressiveness</span></a>
     </ol>
    <li><a href="#possible_impl"><span class="secno">4</span> <span class="content">Possible implementation of a parallel range algorithm</span></a>
    <li>
     <a href="#proposal_scope"><span class="secno">5</span> <span class="content">The proposal scope</span></a>
     <ol class="toc">
      <li>
       <a href="#in_scope"><span class="secno">5.1</span> <span class="content">In-scope</span></a>
       <ol class="toc">
        <li><a href="#cpp17_counterpart"><span class="secno">5.1.1</span> <span class="content">The counterparts of C++17 parallel algorithms in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> namespace</span></a>
        <li><a href="#only_in_std_ranges"><span class="secno">5.1.2</span> <span class="content">Algorithms in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> namespace only</span></a>
       </ol>
      <li>
       <a href="#out_of_scope"><span class="secno">5.2</span> <span class="content">Out-of-scope</span></a>
       <ol class="toc">
        <li><a href="#without_exec_policy_counterpart"><span class="secno">5.2.1</span> <span class="content">The counterparts of exiting algorithms without <code class="highlight"><c- n>ExecutionPolicy</c-></code></span></a>
        <li><a href="#serial_range_based_absence"><span class="secno">5.2.2</span> <span class="content">Absence of some serial range-based algorithms</span></a>
       </ol>
     </ol>
    <li><a href="#impl_exp"><span class="secno">6</span> <span class="content">Implementation experience</span></a>
    <li>
     <a href="#further_work"><span class="secno">7</span> <span class="content">Further work</span></a>
     <ol class="toc">
      <li><a href="#issues_to_address"><span class="secno">7.1</span> <span class="content">Issues to address</span></a>
      <li><a href="#thread_safe_views"><span class="secno">7.2</span> <span class="content">Thread-safe views examination</span></a>
     </ol>
    <li>
     <a href="#formal_wording"><span class="secno">8</span> <span class="content">Formal wording</span></a>
     <ol class="toc">
      <li><a href="#modify_version_syn"><span class="secno">8.1</span> <span class="content">Add the feature test macro to <span>[<strong>version.syn</strong>]</span></span></a>
      <li><a href="#modify_alg_parallel_def"><span class="secno">8.2</span> <span class="content">Modify <span>[<strong>algorithms.parallel.defns</strong>]</span></span></a>
      <li><a href="#modify_alg_parallel_user"><span class="secno">8.3</span> <span class="content">Modify <span>[<strong>algorithms.parallel.user</strong>]</span></span></a>
      <li><a href="#modify_alg_parallel_overloads"><span class="secno">8.4</span> <span class="content">Modify <span>[<strong>algorithms.parallel.overloads</strong>]</span></span></a>
      <li><a href="#modify_alg_all_of"><span class="secno">8.5</span> <span class="content">Modify <code class="highlight"><c- n>all_of</c-></code> in <span>[<strong>alg.all.of</strong>]</span></span></a>
      <li><a href="#modify_alg_any_of"><span class="secno">8.6</span> <span class="content">Modify <code class="highlight"><c- n>any_of</c-></code> in <span>[<strong>alg.any.of</strong>]</span></span></a>
      <li><a href="#modify_alg_none_of"><span class="secno">8.7</span> <span class="content">Modify <code class="highlight"><c- n>none_of</c-></code> in <span>[<strong>alg.none.of</strong>]</span></span></a>
      <li><a href="#modify_alg_contains"><span class="secno">8.8</span> <span class="content">Modify <code class="highlight"><c- n>contains</c-></code> in <span>[<strong>alg.contains</strong>]</span></span></a>
      <li><a href="#modify_alg_foreach"><span class="secno">8.9</span> <span class="content">Modify <code class="highlight"><c- n>for_each</c-></code> in <span>[<strong>alg.foreach</strong>]</span></span></a>
      <li><a href="#modify_alg_find"><span class="secno">8.10</span> <span class="content">Modify <code class="highlight"><c- n>find</c-></code> in <span>[<strong>alg.find</strong>]</span></span></a>
      <li><a href="#modify_alg_find_last"><span class="secno">8.11</span> <span class="content">Modify <code class="highlight"><c- n>find_last</c-></code> in <span>[<strong>alg.find.last</strong>]</span></span></a>
      <li><a href="#modify_alg_find_end"><span class="secno">8.12</span> <span class="content">Modify <code class="highlight"><c- n>find_end</c-></code> in <span>[<strong>alg.find.end</strong>]</span></span></a>
      <li><a href="#modify_alg_find_first_of"><span class="secno">8.13</span> <span class="content">Modify <code class="highlight"><c- n>find_first_of</c-></code> in <span>[<strong>alg.find.first.of</strong>]</span></span></a>
      <li><a href="#modify_alg_adjacent_find"><span class="secno">8.14</span> <span class="content">Modify <code class="highlight"><c- n>adjacent_find</c-></code> in <span>[<strong>alg.adjacent.find</strong>]</span></span></a>
      <li><a href="#modify_alg_count"><span class="secno">8.15</span> <span class="content">Modify <code class="highlight"><c- n>count</c-></code> in <span>[<strong>alg.count</strong>]</span></span></a>
      <li><a href="#modify_alg_mismatch"><span class="secno">8.16</span> <span class="content">Modify <code class="highlight"><c- n>mismatch</c-></code> in <span>[<strong>alg.mismatch</strong>]</span></span></a>
      <li><a href="#modify_alg_equal"><span class="secno">8.17</span> <span class="content">Modify <code class="highlight"><c- n>equal</c-></code> in <span>[<strong>alg.equal</strong>]</span></span></a>
      <li><a href="#modify_alg_search"><span class="secno">8.18</span> <span class="content">Modify <code class="highlight"><c- n>search</c-></code> in <span>[<strong>alg.search</strong>]</span></span></a>
      <li><a href="#modify_alg_starts_with"><span class="secno">8.19</span> <span class="content">Modify <code class="highlight"><c- n>starts_with</c-></code> in <span>[<strong>alg.starts.with</strong>]</span></span></a>
      <li><a href="#modify_alg_ends_with"><span class="secno">8.20</span> <span class="content">Modify <code class="highlight"><c- n>ends_with</c-></code> in <span>[<strong>alg.ends.with</strong>]</span></span></a>
      <li><a href="#modify_copy"><span class="secno">8.21</span> <span class="content">Modify <code class="highlight"><c- n>copy</c-></code> in <span>[<strong>alg.copy</strong>]</span></span></a>
      <li><a href="#modify_move"><span class="secno">8.22</span> <span class="content">Modify <code class="highlight"><c- n>move</c-></code> in <span>[<strong>alg.move</strong>]</span></span></a>
      <li><a href="#modify_swap"><span class="secno">8.23</span> <span class="content">Modify <code class="highlight"><c- n>swap</c-></code> in <span>[<strong>alg.swap</strong>]</span></span></a>
      <li><a href="#modify_transform"><span class="secno">8.24</span> <span class="content">Modify <code class="highlight"><c- n>transform</c-></code> in <span>[<strong>alg.transform</strong>]</span></span></a>
      <li><a href="#modify_replace"><span class="secno">8.25</span> <span class="content">Modify <code class="highlight"><c- n>replace</c-></code> in <span>[<strong>alg.replace</strong>]</span></span></a>
      <li><a href="#modify_fill"><span class="secno">8.26</span> <span class="content">Modify <code class="highlight"><c- n>fill</c-></code> in <span>[<strong>alg.fill</strong>]</span></span></a>
      <li><a href="#modify_generate"><span class="secno">8.27</span> <span class="content">Modify <code class="highlight"><c- n>generate</c-></code> in <span>[<strong>alg.generate</strong>]</span></span></a>
      <li><a href="#modify_remove"><span class="secno">8.28</span> <span class="content">Modify <code class="highlight"><c- n>remove</c-></code> in <span>[<strong>alg.remove</strong>]</span></span></a>
      <li><a href="#modify_unique"><span class="secno">8.29</span> <span class="content">Modify <code class="highlight"><c- n>unique</c-></code> in <span>[<strong>alg.unique</strong>]</span></span></a>
      <li><a href="#modify_reverse"><span class="secno">8.30</span> <span class="content">Modify <code class="highlight"><c- n>reverse</c-></code> in <span>[<strong>alg.reverse</strong>]</span></span></a>
      <li><a href="#modify_rotate"><span class="secno">8.31</span> <span class="content">Modify <code class="highlight"><c- n>rotate</c-></code> in <span>[<strong>alg.rotate</strong>]</span></span></a>
      <li><a href="#modify_shift"><span class="secno">8.32</span> <span class="content">Modify <code class="highlight"><c- n>shift</c-></code> in <span>[<strong>alg.shift</strong>]</span></span></a>
      <li><a href="#modify_sort"><span class="secno">8.33</span> <span class="content">Modify <code class="highlight"><c- n>sort</c-></code> in <span>[<strong>sort</strong>]</span></span></a>
      <li><a href="#modify_stable_sort"><span class="secno">8.34</span> <span class="content">Modify <code class="highlight"><c- n>stable_sort</c-></code> in <span>[<strong>stable.sort</strong>]</span></span></a>
      <li><a href="#modify_partial_sort"><span class="secno">8.35</span> <span class="content">Modify <code class="highlight"><c- n>partial_sort</c-></code> in <span>[<strong>partial.sort</strong>]</span></span></a>
      <li><a href="#modify_partial_sort_copy"><span class="secno">8.36</span> <span class="content">Modify <code class="highlight"><c- n>partial_sort_copy</c-></code> in <span>[<strong>partial.sort.copy</strong>]</span></span></a>
      <li><a href="#modify_is_sorted"><span class="secno">8.37</span> <span class="content">Modify <code class="highlight"><c- n>is_sorted</c-></code> in <span>[<strong>is.sorted</strong>]</span></span></a>
      <li><a href="#modify_nth_element"><span class="secno">8.38</span> <span class="content">Modify <code class="highlight"><c- n>nth_element</c-></code> in <span>[<strong>alg.nth.element</strong>]</span></span></a>
      <li><a href="#modify_partitions"><span class="secno">8.39</span> <span class="content">Modify <code class="highlight"><c- n>partitions</c-></code> in <span>[<strong>alg.partitions</strong>]</span></span></a>
      <li><a href="#modify_merge"><span class="secno">8.40</span> <span class="content">Modify <code class="highlight"><c- n>merge</c-></code> in <span>[<strong>alg.merge</strong>]</span></span></a>
      <li><a href="#modify_includes"><span class="secno">8.41</span> <span class="content">Modify <code class="highlight"><c- n>includes</c-></code> in <span>[<strong>includes</strong>]</span></span></a>
      <li><a href="#modify_set_union"><span class="secno">8.42</span> <span class="content">Modify <code class="highlight"><c- n>set_union</c-></code> in <span>[<strong>set.union</strong>]</span></span></a>
      <li><a href="#modify_set_intersection"><span class="secno">8.43</span> <span class="content">Modify <code class="highlight"><c- n>set_intersection</c-></code> in <span>[<strong>set.intersection</strong>]</span></span></a>
      <li><a href="#modify_set_difference"><span class="secno">8.44</span> <span class="content">Modify <code class="highlight"><c- n>set_difference</c-></code> in <span>[<strong>set.difference</strong>]</span></span></a>
      <li><a href="#modify_set_symmetric_difference"><span class="secno">8.45</span> <span class="content">Modify <code class="highlight"><c- n>set_symmetric_difference</c-></code> in <span>[<strong>set.symmetric.difference</strong>]</span></span></a>
      <li><a href="#modify_is_heap"><span class="secno">8.46</span> <span class="content">Modify <code class="highlight"><c- n>is_heap</c-></code> in <span>[<strong>is.heap</strong>]</span></span></a>
      <li><a href="#modify_alg_min_max"><span class="secno">8.47</span> <span class="content">Modify <code class="highlight"><c- n>min</c-></code>, <code class="highlight"><c- n>max</c-></code>, <code class="highlight"><c- n>minmax</c-></code> in <span>[<strong>alg.min.max</strong>]</span></span></a>
      <li><a href="#modify_alg_lex_comparison"><span class="secno">8.48</span> <span class="content">Modify <code class="highlight"><c- n>lexicographical_compare</c-></code> in <span>[<strong>alg.lex.comparison</strong>]</span></span></a>
      <li><a href="#modify_memory_syn"><span class="secno">8.49</span> <span class="content">Modify <span>[<strong>memory.syn</strong>]</span></span></a>
      <li><a href="#modify_special_mem_concepts"><span class="secno">8.50</span> <span class="content">Add exposition only concepts to <span>[<strong>special.mem.concepts</strong>]</span></span></a>
     </ol>
    <li>
     <a href="#revision_history"><span class="secno">9</span> <span class="content">Revision history</span></a>
     <ol class="toc">
      <li><a href="#r3_r4"><span class="secno">9.1</span> <span class="content">R3 => R4</span></a>
      <li><a href="#r2_r3"><span class="secno">9.2</span> <span class="content">R2 => R3</span></a>
      <li><a href="#r1_r2"><span class="secno">9.3</span> <span class="content">R1 => R2</span></a>
      <li><a href="#r0_r1"><span class="secno">9.4</span> <span class="content">R0 => R1</span></a>
     </ol>
    <li>
     <a href="#polls"><span class="secno">10</span> <span class="content">Polls</span></a>
     <ol class="toc">
      <li><a href="#sg9_wroclaw_2024"><span class="secno">10.1</span> <span class="content">SG9, Wroclaw, 2024</span></a>
      <li><a href="#sg1_wroclaw_2024"><span class="secno">10.2</span> <span class="content">SG1, Wroclaw, 2024</span></a>
      <li><a href="#sg1_sg9_st_louis_2024"><span class="secno">10.3</span> <span class="content">Joint SG1 + SG9, St. Louis, 2024</span></a>
      <li><a href="#sg9_tokyo_2024"><span class="secno">10.4</span> <span class="content">SG9, Tokyo, 2024</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="motivation"><span class="secno">1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation"></a></h2>
   <p>Standard parallel algorithms with execution policies which set semantic requirements to user-provided callable objects
were a good start for supporting parallelism in the C++ standard.</p>
   <p>The C++ Ranges library - ranges, views, etc. - is a powerful facility to produce lazily evaluated pipelines
that can be processed by range-based algorithms. Together they provide a productive and expressive API
with the room for extra optimizations.</p>
   <p>Combining these two powerful features by adding support for execution policies to the range-based algorithms opens
an opportunity to fuse several computations into one parallel algorithm call, thus reducing the overhead on parallelism.
That is especially valuable for heterogeneous implementations of parallel algorithms, for which the range-based API helps
reducing the number of kernels submitted to an accelerator.</p>
   <p>Users are already using ranges and range adaptors by passing range iterators to the existing non-range parallel
algorithms. <a data-link-type="biblio" href="#biblio-p2408r5" title="Ranges iterators as inputs to non-Ranges algorithms">[P2408R5]</a> was adopted to enable this. This pattern is often featured when teaching C++ parallel algorithms
and appears in many codebases.</p>
   <p><code class="highlight"><c- n>iota</c-></code> and <code class="highlight"><c- n>cartesian_product</c-></code> are especially common, as many compute workloads want to iterate over indices, not
objects, and many work with multidimensional data. <code class="highlight"><c- n>transform</c-></code> is also common, as it enables fusion of element-wise
operations into a single parallel algorithm call, which can avoid the need for temporary storage and is more
performant than two separate calls.</p>
   <p>However, passing range iterators to non-range algorithms is unwieldy and verbose. It is surprising to
users that they cannot simply pass the ranges to the parallel algorithms as they would for serial algorithms.</p>
   <table>
    <tbody>
     <tr>
      <th colspan="2">Scalar-Vector Multiply 
     <tr>
      <th>Before 
      <th>After 
     <tr>
      <td>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>span</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-> <c- n>data</c-> <c- o>=</c-> …<c- p>;</c->
<c- b>double</c-> <c- n>C</c-> <c- o>=</c-> …<c- p>;</c->

<c- k>auto</c-> <c- n>indices</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>1</c-><c- p>,</c-> <c- n>data</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->
<c- n>std</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par_unseq</c-><c- p>,</c->
  <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>indices</c-><c- p>),</c->
  <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>indices</c-><c- p>),</c->
  <c- p>[</c-><c- o>=</c-><c- p>]</c-> <c- p>(</c-><c- k>auto</c-> <c- n>i</c-><c- p>)</c-> <c- p>{</c-> <c- n>data</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-> <c- o>*=</c-> <c- n>C</c-><c- p>;</c-> <c- p>});</c->
</pre>
      <td>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>span</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-> <c- n>data</c-> <c- o>=</c-> …<c- p>;</c->
<c- b>double</c-> <c- n>C</c-> <c- o>=</c-> …<c- p>;</c->

<c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par_unseq</c-><c- p>,</c->
  <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>1</c-><c- p>,</c-> <c- n>data</c-><c- p>.</c-><c- n>size</c-><c- p>()),</c->
  <c- p>[</c-><c- o>=</c-><c- p>]</c-> <c- p>(</c-><c- k>auto</c-> <c- n>i</c-><c- p>)</c-> <c- p>{</c-> <c- n>data</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-> <c- o>*=</c-> <c- n>C</c-><c- p>;</c-> <c- p>});</c->
</pre>
   </table>
   <table>
    <tbody>
     <tr>
      <th colspan="2">Matrix Transpose 
     <tr>
      <th>Before 
      <th>After 
     <tr>
      <td>
<pre class="highlight"><code><c- n>std</c-><c- o>::</c-><c- n>mdspan</c-> <c- n>A</c-><c- p>{</c-><c- n>input</c-><c- p>,</c->  <c- n>N</c-><c- p>,</c-> <c- n>M</c-><c- p>};</c->
<c- n>std</c-><c- o>::</c-><c- n>mdspan</c-> <c- n>B</c-><c- p>{</c-><c- n>output</c-><c- p>,</c-> <c- n>M</c-><c- p>,</c-> <c- n>N</c-><c- p>};</c->

<c- k>auto</c-> <c- n>indices</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>cartesian_product</c-><c- p>(</c->
  <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>0</c-><c- p>,</c-> <c- n>A</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- mi>0</c-><c- p>)),</c->
  <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>0</c-><c- p>,</c-> <c- n>A</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- mi>1</c-><c- p>)));</c->

<c- n>std</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par_unseq</c-><c- p>,</c->
  <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>indices</c-><c- p>),</c->
  <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>indices</c-><c- p>),</c->
  <c- p>[</c-><c- o>=</c-><c- p>]</c-> <c- p>(</c-><c- k>auto</c-> <c- n>idx</c-><c- p>)</c-> <c- p>{</c->
    <c- k>auto</c-> <c- p>[</c-><c- n>i</c-><c- p>,</c-> <c- n>j</c-><c- p>]</c-> <c- o>=</c-> <c- n>idx</c-><c- p>;</c->
    <c- n>B</c-><c- p>[</c-><c- n>j</c-><c- p>,</c-> <c- n>i</c-><c- p>]</c-> <c- o>=</c-> <c- n>A</c-><c- p>[</c-><c- n>i</c-><c- p>,</c-> <c- n>j</c-><c- p>];</c->
  <c- p>});</c->
</code></pre>
      <td>
<pre class="highlight"><code><c- n>std</c-><c- o>::</c-><c- n>mdspan</c-> <c- n>A</c-><c- p>{</c-><c- n>input</c-><c- p>,</c->  <c- n>N</c-><c- p>,</c-> <c- n>M</c-><c- p>};</c->
<c- n>std</c-><c- o>::</c-><c- n>mdspan</c-> <c- n>B</c-><c- p>{</c-><c- n>output</c-><c- p>,</c-> <c- n>M</c-><c- p>,</c-> <c- n>N</c-><c- p>};</c->

<c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par_unseq</c-><c- p>,</c->
  <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>cartesian_product</c-><c- p>(</c->
    <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>0</c-><c- p>,</c-> <c- n>A</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- mi>0</c-><c- p>)),</c->
    <c- n>std</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>0</c-><c- p>,</c-> <c- n>A</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- mi>1</c-><c- p>))),</c->
  <c- p>[</c-><c- o>=</c-><c- p>]</c-> <c- p>(</c-><c- k>auto</c-> <c- n>idx</c-><c- p>)</c-> <c- p>{</c->
    <c- k>auto</c-> <c- p>[</c-><c- n>i</c-><c- p>,</c-> <c- n>j</c-><c- p>]</c-> <c- o>=</c-> <c- n>idx</c-><c- p>;</c->
    <c- n>B</c-><c- p>[</c-><c- n>j</c-><c- p>,</c-> <c- n>i</c-><c- p>]</c-> <c- o>=</c-> <c- n>A</c-><c- p>[</c-><c- n>i</c-><c- p>,</c-> <c- n>j</c-><c- p>];</c->
  <c- p>});</c->
</code></pre>
   </table>
   <p>Earlier, <a data-link-type="biblio" href="#biblio-p2500r2" title="C++ parallel algorithms and P2300">[P2500R2]</a> proposed to add the range-based C++ parallel algorithms together with its primary goal of extending
algorithms with schedulers. We have decided to split those parts to separate papers, which could progress independently.</p>
   <h2 class="heading settled" data-level="2" id="design_overview"><span class="secno">2. </span><span class="content">Design overview</span><a class="self-link" href="#design_overview"></a></h2>
   <p>This paper proposes execution policy support for C++ range-based algorithms. In the nutshell, the proposal extends C++
range algorithms with overloads taking any standard or implementation defined C++ execution policy as a function parameter.
These overloads are further referred to as <em>parallel range algorithms</em>.</p>
   <p>The proposal is targeted to C++26.</p>
   <h3 class="heading settled" data-level="2.1" id="design_summary"><span class="secno">2.1. </span><span class="content">Design summary</span><a class="self-link" href="#design_summary"></a></h3>
   <h4 class="heading settled" data-level="2.1.1" id="design_diff_to_cpp20_ranges"><span class="secno">2.1.1. </span><span class="content">Differences to serial range algorithms</span><a class="self-link" href="#design_diff_to_cpp20_ranges"></a></h4>
   <p>Comparing to the C++20 serial range algorithms, we propose the following modifications:</p>
   <ul>
    <li data-md>
     <p>The execution policy parameter is added.</p>
    <li data-md>
     <p><code class="highlight"><c- n>for_each</c-></code> and <code class="highlight"><c- n>for_each_n</c-></code> return only an iterator but not the function.</p>
    <li data-md>
     <p>Parallel range algorithms take a range, not an iterator, as the output for the overloads with ranges, and additionally take
an output sentinel for the "iterator and sentinel" overloads. (<a href="#range_as_the_output">§ 2.7 Taking range as the output</a>)</p>
    <li data-md>
     <p>Until better parallelism-friendly abstractions are proposed, parallel algorithms require <code class="highlight"><c- n>random_access_</c-><c- p>{</c-><c- n>iterator</c-><c- p>,</c-><c- n>range</c-><c- p>}</c-></code>. (<a href="#random_access_requirement">§ 2.6 Requiring random_access_iterator or random_access_range</a>)</p>
    <li data-md>
     <p>All input and output data sequences must be bounded. (<a href="#require_bounded_ranges">§ 2.8 Requiring ranges to be bounded</a>)</p>
   </ul>
   <h4 class="heading settled" data-level="2.1.2" id="design_diff_to_cpp17_par"><span class="secno">2.1.2. </span><span class="content">Differences to C++17 parallel algorithms</span><a class="self-link" href="#design_diff_to_cpp17_par"></a></h4>
   <p>In addition to data sequences being passed as either ranges or "iterator and sentinel" pairs, the following differences
to the C++17 parallel algorithms are proposed:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>for_each</c-></code> returns an iterator, not <code class="highlight"><c- b>void</c-></code>.</p>
    <li data-md>
     <p>Algorithms require <code class="highlight"><c- n>random_access_</c-><c- p>{</c-><c- n>iterator</c-><c- p>,</c-><c- n>range</c-><c- p>}</c-></code>, and not <em>LegacyForwardIterator</em>.</p>
    <li data-md>
     <p>All input and output data sequences must be bounded.</p>
   </ul>
   <h4 class="heading settled" data-level="2.1.3" id="design_other_aspects"><span class="secno">2.1.3. </span><span class="content">Other design aspects</span><a class="self-link" href="#design_other_aspects"></a></h4>
   <ul>
    <li data-md>
     <p>The parallel range algorithms support all standard and implementation-defined execution policies. (<a href="#supported_policies">§ 2.3 Supported execution policies</a>)</p>
    <li data-md>
     <p>Except as mentioned above, the parallel range algorithms should return the same type as the corresponding serial range algorithms. (<a href="#return_type">§ 2.4 Algorithm return types</a>)</p>
    <li data-md>
     <p>The proposed algorithms extend the overload set of algorithm function objects defined in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code>. (<a href="#algorithm_func_objects">§ 2.5 Extending the overload sets of algorithm function objects</a>)</p>
    <li data-md>
     <p>The proposed algorithms should require callable object passed to an algorithm to be <code class="highlight"><c- n>regular_invocable</c-></code> where possible. (<a href="#callable_parameters">§ 2.9 Requirements for callable parameters</a>)</p>
    <li data-md>
     <p>The proposed algorithms should follow the design of C++17 parallel algorithms with regard to <code class="highlight"><c- k>constexpr</c-></code> support. (<a href="#constexpr_support">§ 2.10 constexpr parallel range algorithms</a>)</p>
   </ul>
   <h4 class="heading settled" data-level="2.1.4" id="design_api_example"><span class="secno">2.1.4. </span><span class="content">An example of the proposed API</span><a class="self-link" href="#design_api_example"></a></h4>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>unary_transform_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                      <c- n>F</c-> <c- n>op</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>>></c->
           <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>unary_transform_result</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c-> <c- n>F</c-> <c- n>op</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <h3 class="heading settled" data-level="2.2" id="coexistence_with_schedulers"><span class="secno">2.2. </span><span class="content">Coexistence with schedulers</span><a class="self-link" href="#coexistence_with_schedulers"></a></h3>
   <p>We believe that adding parallel range algorithms does not have the risk of conflict with anticipated scheduler-based
algorithms, because an execution policy does not satisfy the requirements for a policy-aware scheduler (<a data-link-type="biblio" href="#biblio-p2500r2" title="C++ parallel algorithms and P2300">[P2500R2]</a>),
a sender (<a data-link-type="biblio" href="#biblio-p3300r0" title="C++ Asynchronous Parallel Algorithms">[P3300R0]</a>), or really anything else from <a data-link-type="biblio" href="#biblio-p2300r9" title="`std::execution`">[P2300R9]</a> that can be used to specify such algorithms.</p>
   <p>At this point we do not, however, discuss how the appearance of schedulers
may or should impact the execution rules for parallel algorithms specified in <a href="https://eel.is/c++draft/algorithms.parallel.exec">[algorithms.parallel.exec]</a>,
and just assume that the same rules apply to the range algorithms with execution policies.</p>
   <h3 class="heading settled" data-level="2.3" id="supported_policies"><span class="secno">2.3. </span><span class="content">Supported execution policies</span><a class="self-link" href="#supported_policies"></a></h3>
   <p>Parallel range algorithms should operate with the same set of execution policies as the existing parallel algorithms,
that is, <code class="highlight"><c- n>seq</c-></code>, <code class="highlight"><c- n>unseq</c-></code>, <code class="highlight"><c- n>par</c-></code>, and <code class="highlight"><c- n>par_unseq</c-></code> in the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-></code> namespace, as well as any implementation-defined
execution policies.</p>
   <p>We do not propose the parallel range algorithms to be customizable for application-defined execution policies.
We expect such custom policies to become unnecessary once the standard algorithms are capable of working with
schedulers/senders/receivers.</p>
   <h3 class="heading settled" data-level="2.4" id="return_type"><span class="secno">2.4. </span><span class="content">Algorithm return types</span><a class="self-link" href="#return_type"></a></h3>
   <p>We explored possible algorithm return types and came to conclusion that returning the same type as serial range
algorithms is the preferred option to make the changes for enabling parallelism minimal.</p>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>sort</c-><c- p>(</c-><c- n>v</c-><c- p>);</c->
</pre>
   <p>becomes:</p>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>sort</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>);</c->
</pre>
   <p>However, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each_n</c-></code> require special consideration because previous
design decisions suggest that there should be a difference between serial and parallel versions.</p>
   <p>The following table summarizes return value types for the existing variants of these two algorithms:</p>
   <table>
    <tbody>
     <tr>
      <th>API
      <th>Return type
     <tr>
      <td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each</c-></code>
      <td><code class="highlight"><c- n>Function</c-></code>
     <tr>
      <td>Parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each</c-></code>
      <td><code class="highlight"><c- b>void</c-></code>
     <tr>
      <td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each_n</c-></code>
      <td><code class="highlight"><c- n>Iterator</c-></code>
     <tr>
      <td>Parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each_n</c-></code>
      <td><code class="highlight"><c- n>Iterator</c-></code>
     <tr>
      <td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code>
      <td><code class="highlight"><c- n>for_each_result</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>Range</c-><c- o>></c-><c- p>,</c-> <c- n>Function</c-><c- o>></c-></code>
     <tr>
      <td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code>, <code class="highlight"><c- n>I</c-></code> + <code class="highlight"><c- n>S</c-></code> overload
      <td><code class="highlight"><c- n>for_each_result</c-><c- o>&lt;</c-><c- n>Iterator</c-><c- p>,</c-> <c- n>Function</c-><c- o>></c-></code>
     <tr>
      <td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each_n</c-></code>
      <td><code class="highlight"><c- n>for_each_n_result</c-><c- o>&lt;</c-><c- n>Iterator</c-><c- p>,</c-> <c- n>Function</c-><c- o>></c-></code>
   </table>
   <p>While the serial <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each</c-></code> returns the obtained function object with all modifications it might have accumulated,
the return type for the parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each</c-></code> is <code class="highlight"><c- b>void</c-></code> because, as stated in the standard, "parallelization often
does not permit efficient state accumulation". For efficient parallelism an implementation can make multiple copies of
the function object, which for that purpose is allowed to be copyable and not just movable like for the serial <code class="highlight"><c- n>for_each</c-></code>.
That implies that users cannot rely on any state accumulation within that function object, so it does not make sense
(and might be even dangerous) to return it.</p>
   <p>In <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code>, the return type of <code class="highlight"><c- n>for_each</c-></code> and <code class="highlight"><c- n>for_each_n</c-></code> is unified to return both an iterator and the function
object.</p>
   <p>Based on the analysis above and <a href="#sg9_tokyo_2024">the feedback from SG9</a> we think that the most reasonable return type
for parallel variants of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each_n</c-></code> should be:</p>
   <table>
    <tbody>
     <tr>
      <th>API
      <th>Return type
     <tr>
      <td>Parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code>
      <td><code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>Range</c-><c- o>></c-></code>
     <tr>
      <td>Parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code>, <code class="highlight"><c- n>I</c-></code> + <code class="highlight"><c- n>S</c-></code> overload
      <td><code class="highlight"><c- n>Iterator</c-></code>
     <tr>
      <td>Parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each_n</c-></code>
      <td><code class="highlight"><c- n>Iterator</c-></code>
   </table>
   <h3 class="heading settled" data-level="2.5" id="algorithm_func_objects"><span class="secno">2.5. </span><span class="content">Extending the overload sets of algorithm function objects</span><a class="self-link" href="#algorithm_func_objects"></a></h3>
   <p>We believe the proposed functionality should have the same properties and general behavior as serial range algorithms,
particularly regarding the name lookup.</p>
   <p>With the adoption of <a data-link-type="biblio" href="#biblio-p3136r0" title="Retiring niebloids">[P3136R0]</a>, function templates in the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> namespace have been respecified as <em>algorithm function objects</em>. These objects are defined as sets of one or more overloaded function templates,
which names designate the objects.</p>
   <p>The parallel range algorithms we propose will extend the overload sets for the respective algorithm function objects.
The name lookup rules for such objects will apply automatically. It is covered by the wording proposed in <a data-link-type="biblio" href="#biblio-p3136r0" title="Retiring niebloids">[P3136R0]</a>;
additional changes are not needed.</p>
   <p>From the implementation standpoint, adding parallel versions of the range algorithms to the overload set should not be
a problem. Please see <a href="#possible_impl">§ 4 Possible implementation of a parallel range algorithm</a> for more information.</p>
   <h3 class="heading settled" data-level="2.6" id="random_access_requirement"><span class="secno">2.6. </span><span class="content">Requiring <code class="highlight"><c- n>random_access_iterator</c-></code> or <code class="highlight"><c- n>random_access_range</c-></code></span><a class="self-link" href="#random_access_requirement"></a></h3>
   <p>C++17 parallel algorithms minimally require <em>LegacyForwardIterator</em> for data sequences, but in our opinion, it is not quite
suitable for an efficient parallel implementation. Therefore for parallel range algorithms we propose to require
random access ranges and iterators.</p>
   <p>Using parallel algorithms with forward ranges will in most cases give little to no benefit,
and may even reduce performance due to extra overheads. We believe that forward ranges and iterators are bad abstractions
for parallel data processing, and allowing those could result in wrong expectations and unsatisfactory user experience
with parallel algorithms.</p>
   <p>Many parallel programming models that are well known and widely used in the industry, including OpenMP, OpenCL, CUDA,
SYCL, oneTBB, define iteration or data spaces for their parallel constructs in ways that allow creating sufficient
parallel work quickly and efficiently. A key property for this is the ability to split the work into smaller chunks.
These programming models allow to control the amount of work per chunk and sometimes the ways chunks are created
and/or scheduled. All these also support iteration spaces up to at least 3 dimensions.</p>
   <p>Except for <code class="highlight"><c- n>tbb</c-><c- o>::</c-><c- n>parallel_for_each</c-></code> in oneTBB which can work with forward iterators, these parallel programming models
require random access iterators or some equivalent, such as numeric indexes or pointers. This is natural,
as referring to an arbitrary point in the iteration space at constant time is the main and by far simplest way
to create parallel work. Forward iterators, on the other hand, are notoriously bad for splitting a sequence
that can only be done in linear time. Moreover, if the output of an algorithm should preserve the order of its input,
which is typical for the C++ algorithms, it requires additional synchronization or/and additional space with forward
iterators and comes almost for granted with random access ones.</p>
   <p>These very programming models are often used as backends to implement the C++ standard parallelism. Not surprisingly,
most implementations fall back to serial processing if data sequences have no random access. Of the GNU libstdc++,
LLVM libc++, and MSVC’s standard library, only the latter attempts to process forward iterator based sequences in parallel,
for which it first needs to serially iterate over a whole sequence once or even twice.
oneAPI DPC++ library (oneDPL) supports forward iterators only for a very few algorithms,
only for <code class="highlight"><c- n>par</c-></code> and only in the implementation based on oneTBB.</p>
   <p>According to the SG1/SG9 feedback we have got earlier, there seemingly are two main reasons why others do not want to restrict
parallel algorithms by only random access ranges:</p>
   <ul>
    <li data-md>
     <p>That would prevent some useful views, such as <code class="highlight"><c- n>filter_view</c-></code>, from being used with parallel range algorithms.</p>
    <li data-md>
     <p>That would be inconsistent with the C++17 parallel algorithms.</p>
   </ul>
   <p>Given the other aspects of the proposed design, we believe some degree of inconsistency with C++17 parallel algorithms
is inevitable and should not become a gating factor for important design decisions.</p>
   <p>The question of supporting the standard views that do not provide random access is very important. We think though
that it should better be addressed through proper abstractions and new concepts defining iteration spaces, including
multidimensional ones, suitable for parallel algorithms. We intend to work on developing these (likely in another paper),
however it requires time and effort to make it right, and we think trying to squeeze that into C++26 adds significant risks.
For now, random access ranges with known bounds (see <a href="#require_bounded_ranges">§ 2.8 Requiring ranges to be bounded</a>) is probably the best approximation
that exists in the standard. Starting from that and gradually enabling other types of iteration spaces
in a source-compatible manner seems to us better than blanket allowance of any <code class="highlight"><c- n>forward_range</c-></code>.</p>
   <h3 class="heading settled" data-level="2.7" id="range_as_the_output"><span class="secno">2.7. </span><span class="content">Taking range as the output</span><a class="self-link" href="#range_as_the_output"></a></h3>
   <p>We propose taking a range as the output for the overloads that take ranges for input.
Similarly, we propose requiring a sentinel for the output where the input is passed as "iterator and sentinel".</p>
   <p>The benefits of this <em>range-as-the-output</em> approach, comparing to taking a single iterator for the output, are:</p>
   <ul>
    <li data-md>
     <p>It creates a safer API where all data sequences have known bounds. Specifically, the <code class="highlight"><c- n>sized_range</c-></code> and <code class="highlight"><c- n>sized_sentinel_for</c-></code> concepts will be applied to the output sequences in the same way as to the input sequences.</p>
    <li data-md>
     <p>Not for all algorithms the output size is defined by the input size. An example is <code class="highlight"><c- n>copy_if</c-></code> (and similar
algorithms with <em>filtering</em> semantics), where the output sequence might be shorter than the input one.
Knowing the expected size of the output may open opportunities for more efficient implementations.</p>
    <li data-md>
     <p>Passing a range for the output makes code a bit simpler in the cases typical for parallel execution.</p>
   </ul>
   <p>On the joint SG1 and SG9 discussion of <a data-link-type="biblio" href="#biblio-p3179r2" title="C++ parallel range algorithms">[P3179R2]</a> the audience expressed several concerns about the idea and <a href="#sg1_sg9_st_louis_2024">requested to stay with iterators for the output</a> until deeper investigation is made.</p>
   <p>To address the concerns, we wrote a separate paper <a data-link-type="biblio" href="#biblio-p3490r0" title="Justification for range-as-an-output for parallel range algorithms">[P3490R0]</a> with the detailed investigation of the topic,
suggesting there a compromise solution with adding separate function template overloads for both <em>iterator-as-the-output</em> and <em>range-as-the-output</em>. See <a data-link-type="biblio" href="#biblio-p3490r0" title="Justification for range-as-an-output for parallel range algorithms">[P3490R0]</a> for more details.</p>
   <p>Eventually SG9 <a href="#sg9_wroclaw_2024">accepted</a> our original proposal to use ranges for the output, without extra overloads
for legacy convenience.</p>
   <h3 class="heading settled" data-level="2.8" id="require_bounded_ranges"><span class="secno">2.8. </span><span class="content">Requiring ranges to be bounded</span><a class="self-link" href="#require_bounded_ranges"></a></h3>
   <p>One of the requirements we want to put on the parallel range algorithms is to disallow unbounded input and output.
The reasons for that are:</p>
   <ul>
    <li data-md>
     <p>For efficient parallel implementation we need to know the iteration space bounds. Otherwise, it’s hard to
apply the "divide and conquer" strategy for creating work for multiple execution threads.</p>
    <li data-md>
     <p>While serial range algorithms allow passing an "infinite" range like <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>views</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>0</c-><c- p>)</c-></code>,
it may result in an endless loop. It’s hard to imagine usefulness of that in the case of parallel execution.
Requiring data sequences to be bounded potentially prevents errors at run-time.</p>
    <li data-md>
     <p>Using explicitly bounded output ranges follows established practices of secure coding, which recommend or even
require to always specify the size of the output in order to prevent out-of-range data modifications.</p>
   </ul>
   <p>If several provided ranges or sequences are bounded, an algorithm should stop as soon as the end is reached for the shortest one.
There are already precedents in the standard that an algorithm takes two sequences with potentially different input sizes
and chooses the smaller size as the number of iterations it is going to make, such as <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>transform</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-></code>. For the record, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>transform</c-></code> (including the overload with execution policy) doesn’t support
different input sizes, while <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>mismatch</c-></code> does.</p>
   <p>In the case of two input ranges or sequences, for a few algorithms - namely, <code class="highlight"><c- n>mismatch</c-></code>, <code class="highlight"><c- n>equal</c-></code>, and <code class="highlight"><c- n>transform</c-></code> -
it could be sufficient for just one range to be bounded and the other assumed to have at least as many elements
as the bounded one. This enables unbounded ranges such as <code class="highlight"><c- n>views</c-><c- o>::</c-><c- n>repeat</c-></code> in certain useful patterns, for example:</p>
<pre class="language-cpp highlight"><c- b>void</c-> <c- nf>normalize_parallel</c-><c- p>(</c-><c- n>range</c-> <c- k>auto</c-><c- o>&amp;&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- p>{</c->
  <c- k>auto</c-> <c- n>mx</c-> <c- o>=</c-> <c- n>reduce</c-><c- p>(</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>max</c-><c- p>{});</c->
  <c- n>transform</c-><c- p>(</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>,</c-> <c- n>views</c-><c- o>::</c-><c- n>repeat</c-><c- p>(</c-><c- n>mx</c-><c- p>),</c-> <c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>divides</c-><c- p>);</c->
<c- p>}</c->
</pre>
   <p>However, SG9 <a href="#sg9_wroclaw_2024">decided</a> to require <code class="highlight"><c- n>sized_range</c-></code> for all inputs, with the plan to relax these constraints
for <code class="highlight"><c- n>transform</c-></code> once there is a way to statically detect infinite ranges like <code class="highlight"><c- n>views</c-><c- o>::</c-><c- n>repeat</c-></code> (as opposed to finite unsized
ranges, such as null terminated strings).</p>
   <h3 class="heading settled" data-level="2.9" id="callable_parameters"><span class="secno">2.9. </span><span class="content">Requirements for callable parameters</span><a class="self-link" href="#callable_parameters"></a></h3>
   <p>In <a data-link-type="biblio" href="#biblio-p3179r0" title="C++ parallel range algorithms">[P3179R0]</a> we proposed that parallel range algorithms should require function objects for predicates, comparators, etc.
to have <code class="highlight"><c- k>const</c-></code>-qualified <code class="highlight"><c- k>operator</c-><c- p>()</c-></code>, with the intent to provide compile-time diagnostics for mutable	function objects
which might be unsafe for parallel execution. We have got contradictory feedback from SG1 and SG9 on that topic:
SG1 preferred to keep the behavior consistent with C++17 parallel algorithms, while SG9 supported our design intent.</p>
   <p>We did extra investigation and decided that requiring <code class="highlight"><c- k>const</c-></code>-qualified operator at compile-time is not strictly necessary
because:</p>
   <ul>
    <li data-md>
     <p>The vast majority of the serial range algorithms requires function objects to be <code class="highlight"><c- n>regular_invocable</c-></code> (or its derivatives),
which already has the semantic requirement of not modifying either the function object or its arguments.
While not enforced at compile-time, it seems good enough for our purpose because it demands having the same function
object state between invocations (independently of <code class="highlight"><c- k>const</c-></code> qualifier), and it is consistent with serial range algorithms.</p>
    <li data-md>
     <p>Remaining algorithms should be considered individually. For example, <code class="highlight"><c- n>for_each</c-></code> using a mutable <code class="highlight"><c- k>operator</c-><c- p>()</c-></code> is of less
concern if the algorithm does not return the function object (see more detailed analysis below).
For <code class="highlight"><c- n>generate</c-></code>, a non-mutable callable appears to be of very limited use: in order to produce multiple values while not
taking any arguments, a generator should typically maintain and update some state.</p>
   </ul>
   <p>The following example works fine for serial code. While it compiles for parallel code, users should not assume that the
semantics remains intact. Since the parallel version of <code class="highlight"><c- n>for_each</c-></code> requires function object to be copyable, it
is not guaranteed that all <code class="highlight"><c- n>for_each</c-></code> iterations are processed by the same function object. Practically speaking, users
cannot rely on accumulating any state modifications in a parallel <code class="highlight"><c- n>for_each</c-></code> call.</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>callable</c->
<c- p>{</c->
    <c- b>void</c-> <c- nf>operator</c-><c- p>()(</c-><c- b>int</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c->
    <c- p>{</c->
        <c- o>++</c-><c- n>x</c-><c- p>;</c->
        <c- o>++</c-><c- n>i</c-><c- p>;</c-> <c- c1>// a data race if the callable is executed concurrently</c->
    <c- p>}</c->
    <c- b>int</c-> <c- nf>get_i</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c->
        <c- k>return</c-> <c- n>i</c-><c- p>;</c->
    <c- p>}</c->
<c- k>private</c-><c- o>:</c->
    <c- b>int</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c->
<c- p>};</c->

<c- n>callable</c-> <c- n>c</c-><c- p>;</c->

<c- c1>// serial for_each call</c->
<c- k>auto</c-> <c- n>fun</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- n>c</c-><c- p>);</c->

<c- c1>// parallel for_each call</c->
<c- c1>// The callable object cannot be read because parallel for_each version purposefully returns void</c->
<c- n>std</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- n>c</c-><c- p>);</c->

<c- c1>// for_each serial range version call</c->
<c- k>auto</c-> <c- p>[</c-><c- n>_</c-><c- p>,</c-> <c- n>fun</c-><c- p>]</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- n>c</c-><c- p>);</c->
</pre>
   <p>We allow the same callable to be used in the proposed <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code>.</p>
<pre class="language-cpp highlight"><c- c1>// callable is used from the previous code snippet</c->
<c- n>callable</c-> <c- n>c</c-><c- p>;</c->
<c- c1>// The returned iterator is ignored</c->
<c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- n>c</c-><c- p>);</c->
</pre>
   <p>Again, even though <code class="highlight"><c- n>c</c-></code> accumulates state modifications, one cannot rely on that because an algorithm implementation
is allowed to make as many copies of <code class="highlight"><c- n>c</c-></code> as it wants. Of course, this can be overcome by using <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>reference_wrapper</c-></code> but that might lead to data races.</p>
<pre class="language-cpp highlight"><c- c1>// callable is used from the previous code snippet</c->
<c- c1>// Wrapping a callable object with std::reference_wrapper compiles, but might result in data races</c->
<c- n>callable</c-> <c- n>c</c-><c- p>;</c->
<c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- n>std</c-><c- o>::</c-><c- n>ref</c-><c- p>(</c-><c- n>c</c-><c- p>));</c->
</pre>
   <p>Our conclusion is that it’s user responsibility to provide such a callable that avoids data races, same as for C++17 parallel
algorithms.</p>
   <h3 class="heading settled" data-level="2.10" id="constexpr_support"><span class="secno">2.10. </span><span class="content"><code class="highlight"><c- k>constexpr</c-></code> parallel range algorithms</span><a class="self-link" href="#constexpr_support"></a></h3>
   <p><a data-link-type="biblio" href="#biblio-p2902r0" title="constexpr &apos;Parallel&apos; Algorithms">[P2902R0]</a> suggests allowing algorithms with execution policies to be used in constant expressions.
We do not consider that as a primary design goal for our work, however we will happily align with that proposal
in the future once it progresses towards adoption into the working draft.</p>
   <h2 class="heading settled" data-level="3" id="more_examples"><span class="secno">3. </span><span class="content">More examples</span><a class="self-link" href="#more_examples"></a></h2>
   <h3 class="heading settled" data-level="3.1" id="easy_to_switch"><span class="secno">3.1. </span><span class="content">Change existing code to use parallel range algorithms</span><a class="self-link" href="#easy_to_switch"></a></h3>
   <p>One of the goals is to require a minimal amount of changes when switching from the existing API to parallel range
algorithms. However, that simplicity should not create hidden issues negatively impacting the overall user experience.
We believe that the proposal provides a good balance in that regard.</p>
   <p>As an example, let’s look at using <code class="highlight"><c- n>for_each</c-></code> to apply a lambda function to all elements of a <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-> <c- n>v</c-></code>.</p>
   <p>For the serial range-based <code class="highlight"><c- n>for_each</c-></code> call:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>v</c-><c- p>,</c-> <c- p>[](</c-><c- k>auto</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c-> <c- o>++</c-><c- n>x</c-><c- p>;</c-> <c- p>});</c->
</pre>
   <p>switching to the parallel version will look like:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>,</c-> <c- p>[](</c-><c- k>auto</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c-> <c- o>++</c-><c- n>x</c-><c- p>;</c-> <c- p>});</c->
</pre>
   <p>In this simple case, the only change is an execution policy added as the first function argument. It will also hold for
the "iterator and sentinel" overload of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code>.</p>
   <p>The C++17 parallel <code class="highlight"><c- n>for_each</c-></code> call:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- p>[](</c-><c- k>auto</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c-> <c- o>++</c-><c- n>x</c-><c- p>;</c-> <c- p>});</c->
</pre>
   <p>can be changed to one of the following:</p>
<pre class="language-cpp highlight"><c- c1>// Using iterator and sentinel</c->
<c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>(),</c-> <c- p>[](</c-><c- k>auto</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c-> <c- o>++</c-><c- n>x</c-><c- p>;</c-> <c- p>});</c->

<c- c1>// Using vector as a range</c->
<c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>par</c-><c- p>,</c-> <c- n>v</c-><c- p>,</c-> <c- p>[](</c-><c- k>auto</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c-> <c- o>++</c-><c- n>x</c-><c- p>;</c-> <c- p>});</c->
</pre>
   <p>So, here only changing the namespace is necessary, though users might also change <code class="highlight"><c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>v</c-><c- p>.</c-><c- n>end</c-><c- p>()</c-></code> to just <code class="highlight"><c- n>v</c-></code>.</p>
   <p>However, for other algorithms more changes might be necessary.</p>
   <h3 class="heading settled" data-level="3.2" id="less_parallel_call"><span class="secno">3.2. </span><span class="content">Less parallel algorithm calls and better expressiveness</span><a class="self-link" href="#less_parallel_call"></a></h3>
   <p>Let’s consider the following example:</p>
<pre class="language-cpp highlight"><c- n>reverse</c-><c- p>(</c-><c- n>policy</c-><c- p>,</c-> <c- n>begin</c-><c- p>(</c-><c- n>data</c-><c- p>),</c-> <c- n>end</c-><c- p>(</c-><c- n>data</c-><c- p>));</c->
<c- n>transform</c-><c- p>(</c-><c- n>policy</c-><c- p>,</c-> <c- n>begin</c-><c- p>(</c-><c- n>data</c-><c- p>),</c-> <c- n>end</c-><c- p>(</c-><c- n>data</c-><c- p>),</c-> <c- n>begin</c-><c- p>(</c-><c- n>result</c-><c- p>),</c-> <c- p>[](</c-><c- k>auto</c-> <c- n>i</c-><c- p>){</c-> <c- k>return</c-> <c- n>i</c-> <c- o>*</c-> <c- n>i</c-><c- p>;</c-> <c- p>});</c->
<c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>find_if</c-><c- p>(</c-><c- n>policy</c-><c- p>,</c-> <c- n>begin</c-><c- p>(</c-><c- n>result</c-><c- p>),</c-> <c- n>end</c-><c- p>(</c-><c- n>result</c-><c- p>),</c-> <c- n>pred</c-><c- p>);</c->
</pre>
   <p>It has three stages and eventually tries to answer the question if the input sequence contains an element after reversing
and transforming it. The interesting considerations are:</p>
   <ul>
    <li data-md>
     <p>Since the example has three parallel stages, it adds extra overhead for parallel computation per algorithm.</p>
    <li data-md>
     <p>The first two stages will complete for all elements before the <code class="highlight"><c- n>any_of</c-></code> stage is started, though it is not required for
correctness. If reverse and transformation would be done on the fly, a good implementation of <code class="highlight"><c- n>any_of</c-></code> might have
skipped the remaining work when <code class="highlight"><c- n>pred</c-></code> returns <code class="highlight">true</code>, thus providing more performance.</p>
   </ul>
   <p>Let’s make it better:</p>
<pre class="language-cpp highlight"><c- c1>// With fancy iterators</c->
<c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>find_if</c-><c- p>(</c-><c- n>policy</c-><c- p>,</c->
                  <c- n>make_transform_iterator</c-><c- p>(</c-><c- n>make_reverse_iterator</c-><c- p>(</c-><c- n>end</c-><c- p>(</c-><c- n>data</c-><c- p>)),</c->
                                          <c- p>[](</c-><c- k>auto</c-> <c- n>i</c-><c- p>){</c-> <c- k>return</c-> <c- n>i</c-> <c- o>*</c-> <c- n>i</c-><c- p>;</c-> <c- p>}),</c->
                  <c- n>make_transform_iterator</c-><c- p>(</c-><c- n>make_reverse_iterator</c-><c- p>(</c-><c- n>begin</c-><c- p>(</c-><c- n>data</c-><c- p>)),</c->
                                          <c- p>[](</c-><c- k>auto</c-> <c- n>i</c-><c- p>){</c-> <c- k>return</c-> <c- n>i</c-> <c- o>*</c-> <c- n>i</c-><c- p>;</c-> <c- p>}),</c->
                  <c- n>pred</c-><c- p>);</c->
</pre>
   <p>Now there is only one parallel algorithm call, and <code class="highlight"><c- n>any_of</c-></code> can skip unneeded work. However, this
variation also has interesting considerations:</p>
   <ul>
    <li data-md>
     <p>First, it doesn’t compile. We use <code class="highlight"><c- n>transform</c-> <c- n>iterator</c-></code> to pass the transformation function,
but the two <code class="highlight"><c- n>make_transform_iterator</c-></code> expressions use two different lambdas, and
the iterator type for <code class="highlight"><c- n>any_of</c-></code> cannot be deduced because the types of <code class="highlight"><c- n>transform_iterator</c-></code> do not match.
One of the options to make it compile is to store a lambda in a variable.</p>
    <li data-md>
     <p>Second, it requires using a non-standard iterator.</p>
    <li data-md>
     <p>Third, the expressiveness of the code is not good: it is hard to read while easy to make a mistake
like the one described in the first bullet.</p>
   </ul>
   <p>Let’s improve the example further with the proposed API:</p>
<pre class="language-cpp highlight"><c- c1>// With ranges</c->
<c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>find_if</c-><c- p>(</c-><c- n>policy</c-><c- p>,</c-> <c- n>data</c-> <c- o>|</c-> <c- n>views</c-><c- o>::</c-><c- n>reverse</c-> <c- o>|</c-> <c- n>views</c-><c- o>::</c-><c- n>transform</c-><c- p>([](</c-><c- k>auto</c-> <c- n>i</c-><c- p>){</c-> <c- k>return</c-> <c- n>i</c-> <c- o>*</c-> <c- n>i</c-><c- p>;</c-> <c- p>}),</c->
                  <c- n>pred</c-><c- p>);</c->
</pre>
   <p>The example above lacks the drawbacks described for the previous variations:</p>
   <ul>
    <li data-md>
     <p>There is only one algorithm call;</p>
    <li data-md>
     <p>The implementation might skip unnecessary work;</p>
    <li data-md>
     <p>There is no room for the lambda type mistake;</p>
    <li data-md>
     <p>The readability is much better compared to the second variation and not worse than in the first one.</p>
   </ul>
   <h2 class="heading settled" data-level="4" id="possible_impl"><span class="secno">4. </span><span class="content">Possible implementation of a parallel range algorithm</span><a class="self-link" href="#possible_impl"></a></h2>
   <p>Here we show a possible implementation of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-></code> with the new overloads
proposed in <a href="#modify_alg_foreach">§ 8.9 Modify for_each in [alg.foreach]</a>:</p>
<pre class="language-cpp highlight"><c- c1>// A possible implementation of std::ranges::for_each</c->
<c- k>namespace</c-> <c- nn>ranges</c->
<c- p>{</c->
<c- k>namespace</c-> <c- nn>__detail</c->
<c- p>{</c->
<c- k>struct</c-> <c- nc>__for_each_fn</c->
<c- p>{</c->
    <c- c1>// ...</c->
    <c- c1>// Existing serial overloads</c->
    <c- c1>// ...</c->

    <c- c1>// The overload for unsequenced and parallel policies. Requires random_access_iterator</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
             <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
    <c- k>requires</c-> <c- n>is_execution_policy_v</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>remove_cvref_t</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>>></c->
    <c- n>I</c->
    <c- k>operator</c-><c- p>()(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{})</c-> <c- k>const</c->
    <c- p>{</c->
        <c- c1>// properly handle the execution policy;</c->
        <c- c1>// for the reference, a serial implementation is provided</c->
        <c- k>for</c-> <c- p>(;</c-> <c- n>first</c-> <c- o>!=</c-> <c- n>last</c-><c- p>;</c-> <c- o>++</c-><c- n>first</c-><c- p>)</c->
        <c- p>{</c->
            <c- n>std</c-><c- o>::</c-><c- n>invoke</c-><c- p>(</c-><c- n>f</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>first</c-><c- p>));</c->
        <c- p>}</c->
        <c- k>return</c-> <c- n>first</c-><c- p>;</c->
    <c- p>}</c->

    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
             <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
    <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- k>operator</c-><c- p>()(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{})</c-> <c- k>const</c->
    <c- p>{</c->
        <c- k>return</c-> <c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c->
                       <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>f</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c->
    <c- p>}</c->
<c- p>};</c-> <c- c1>// struct for_each</c->
<c- p>}</c-> <c- c1>// namespace __detail</c->
<c- kr>inline</c-> <c- k>namespace</c-> <c- nn>__for_each_fn_namespace</c->
<c- p>{</c->
<c- kr>inline</c-> <c- k>constexpr</c-> <c- n>__detail</c-><c- o>::</c-><c- n>__for_each_fn</c-> <c- n>for_each</c-><c- p>;</c->
<c- p>}</c-> <c- c1>// __for_each_fn_namespace</c->
<c- p>}</c-> <c- c1>// namespace ranges</c->
</pre>
   <h2 class="heading settled" data-level="5" id="proposal_scope"><span class="secno">5. </span><span class="content">The proposal scope</span><a class="self-link" href="#proposal_scope"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="in_scope"><span class="secno">5.1. </span><span class="content">In-scope</span><a class="self-link" href="#in_scope"></a></h3>
   <h4 class="heading settled" data-level="5.1.1" id="cpp17_counterpart"><span class="secno">5.1.1. </span><span class="content">The counterparts of C++17 parallel algorithms in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> namespace</span><a class="self-link" href="#cpp17_counterpart"></a></h4>
   <table>
    <tbody>
     <tr>
      <td><code class="highlight"><c- n>all_of</c-></code> 
      <td><code class="highlight"><c- n>search</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
      <td><code class="highlight"><c- n>remove_copy</c-></code> 
      <td><code class="highlight"><c- n>is_sorted</c-></code> 
      <td><code class="highlight"><c- n>is_heap</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>any_of</c-></code> 
      <td><code class="highlight"><c- n>copy</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
      <td><code class="highlight"><c- n>remove_copy_if</c-></code> 
      <td><code class="highlight"><c- n>is_sorted_until</c-></code> 
      <td><code class="highlight"><c- n>is_heap_until</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>none_of</c-></code> 
      <td><code class="highlight"><c- n>copy_if</c-></code> 
      <td><code class="highlight"><c- n>unique</c-></code> 
      <td><code class="highlight"><c- n>nth_element</c-></code> 
      <td><code class="highlight"><c- n>min_element</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>for_each</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
      <td><code class="highlight"><c- n>move</c-></code> 
      <td><code class="highlight"><c- n>unique_copy</c-></code> 
      <td><code class="highlight"><c- n>is_partitioned</c-></code> 
      <td><code class="highlight"><c- n>max_element</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find</c-></code> 
      <td><code class="highlight"><c- n>swap_ranges</c-></code> 
      <td><code class="highlight"><c- n>reverse</c-></code> 
      <td><code class="highlight"><c- n>partition</c-></code> 
      <td><code class="highlight"><c- n>minmax_element</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_if</c-></code> 
      <td><code class="highlight"><c- n>transform</c-></code> 
      <td><code class="highlight"><c- n>reverse_copy</c-></code> 
      <td><code class="highlight"><c- n>stable_partition</c-></code> 
      <td><code class="highlight"><c- n>lexicographical_compare</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_if_not</c-></code> 
      <td><code class="highlight"><c- n>replace</c-></code> 
      <td><code class="highlight"><c- n>rotate</c-></code> 
      <td><code class="highlight"><c- n>partition_copy</c-></code> 
      <td><code class="highlight"><c- n>uninitialized_default_construct</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_end</c-></code> 
      <td><code class="highlight"><c- n>replace_if</c-></code> 
      <td><code class="highlight"><c- n>rotate_copy</c-></code> 
      <td><code class="highlight"><c- n>merge</c-></code> 
      <td><code class="highlight"><c- n>uninitialized_value_construct</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_first_of</c-></code> 
      <td><code class="highlight"><c- n>replace_copy</c-></code> 
      <td><code class="highlight"><c- n>shift_left</c-></code> 
      <td><code class="highlight"><c- n>inplace_merge</c-></code> 
      <td><code class="highlight"><c- n>uninitialized_copy</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>adjacent_find</c-></code> 
      <td><code class="highlight"><c- n>replace_copy_if</c-></code> 
      <td><code class="highlight"><c- n>shift_right</c-></code> 
      <td><code class="highlight"><c- n>includes</c-></code> 
      <td><code class="highlight"><c- n>uninitialized_move</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>count</c-></code> 
      <td><code class="highlight"><c- n>fill</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
      <td><code class="highlight"><c- n>sort</c-></code> 
      <td><code class="highlight"><c- n>set_union</c-></code> 
      <td><code class="highlight"><c- n>uninitialized_fill</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>count_if</c-></code> 
      <td><code class="highlight"><c- n>generate</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
      <td><code class="highlight"><c- n>stable_sort</c-></code> 
      <td><code class="highlight"><c- n>set_intersection</c-></code> 
      <td><code class="highlight"><c- n>destroy</c-><c- p>{</c-><c- n>_n</c-><c- p>}</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>mismatch</c-></code> 
      <td><code class="highlight"><c- n>remove</c-></code> 
      <td><code class="highlight"><c- n>partial_sort</c-></code> 
      <td><code class="highlight"><c- n>set_difference</c-></code> 
      <td>
     <tr>
      <td><code class="highlight"><c- n>equal</c-></code> 
      <td><code class="highlight"><c- n>remove_if</c-></code> 
      <td><code class="highlight"><c- n>partial_sort_copy</c-></code> 
      <td><code class="highlight"><c- n>set_symmetric_difference</c-></code> 
      <td>
   </table>
   <h4 class="heading settled" data-level="5.1.2" id="only_in_std_ranges"><span class="secno">5.1.2. </span><span class="content">Algorithms in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> namespace only</span><a class="self-link" href="#only_in_std_ranges"></a></h4>
   <p>The algorithms below are easy to add because they are either expressible via existing parallel algorithms or
an analogue with very close semantics exists:</p>
   <table>
    <tbody>
     <tr>
      <th><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> algorithms to add 
      <th><code class="highlight"><c- n>std</c-></code> algorithms used as the guidance 
     <tr>
      <td><code class="highlight"><c- n>contains</c-></code> 
      <td><code class="highlight"><c- n>find</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>contains_subrange</c-></code> 
      <td><code class="highlight"><c- n>search</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_last</c-></code> 
      <td><code class="highlight"><c- n>find</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_last_if</c-></code> 
      <td><code class="highlight"><c- n>find_if</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>find_last_if_not</c-></code> 
      <td><code class="highlight"><c- n>find_if_not</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>starts_with</c-></code> 
      <td><code class="highlight"><c- n>mismatch</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>ends_with</c-></code> 
      <td><code class="highlight"><c- n>equal</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>min</c-></code> 
      <td><code class="highlight"><c- n>min_element</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>max</c-></code> 
      <td><code class="highlight"><c- n>max_element</c-></code> 
     <tr>
      <td><code class="highlight"><c- n>minmax</c-></code> 
      <td><code class="highlight"><c- n>minmax_element</c-></code> 
   </table>
   <h3 class="heading settled" data-level="5.2" id="out_of_scope"><span class="secno">5.2. </span><span class="content">Out-of-scope</span><a class="self-link" href="#out_of_scope"></a></h3>
   <h4 class="heading settled" data-level="5.2.1" id="without_exec_policy_counterpart"><span class="secno">5.2.1. </span><span class="content">The counterparts of exiting algorithms without <code class="highlight"><c- n>ExecutionPolicy</c-></code></span><a class="self-link" href="#without_exec_policy_counterpart"></a></h4>
   <p>Below we list the algorithms below without <code class="highlight"><c- n>ExecutionPolicy</c-></code> in C++17 and where <code class="highlight"><c- n>ExecutionPolicy</c-></code> parameter doesn’t seem
to add value:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>push_heap</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>pop_heap</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>sort_heap</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>next_permutation</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>prev_permutation</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>lower_bound</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>upper_bound</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>equal_range</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>binary_search</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>partition_point</c-></code></p>
   </ul>
   <p>Below we list the algorithms below without <code class="highlight"><c- n>ExecutionPolicy</c-></code> in C++17, where <code class="highlight"><c- n>ExecutionPolicy</c-></code> parameter might make sense
but requires deeper investigation:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>iota</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>make_heap</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>is_permutation</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>copy_backward</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>move_backward</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>sample</c-></code> (RNG specific)</p>
    <li data-md>
     <p><code class="highlight"><c- n>shuffle</c-></code> (RNG specific)</p>
   </ul>
   <p>Below we list <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> only algorithms where we don’t add the <code class="highlight"><c- n>ExecutionPolicy</c-></code> parameter:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>fold_left</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>fold_left_first</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>fold_right</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>fold_right_last</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>fold_left_with_iter</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>fold_left_first_with_iter</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>generate_random</c-></code> (RNG specific, <code class="highlight"><c- n>ExecutionPolicy</c-></code> parameter was already discussed during <a data-link-type="biblio" href="#biblio-p1068r11" title="Vector API for random number generation">[P1068R11]</a> review)</p>
   </ul>
   <h4 class="heading settled" data-level="5.2.2" id="serial_range_based_absence"><span class="secno">5.2.2. </span><span class="content">Absence of some serial range-based algorithms</span><a class="self-link" href="#serial_range_based_absence"></a></h4>
   <p>We understand that some useful algorithms do not yet exist in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code>, for example, most of generalized numeric
operations <a href="https://eel.is/c++draft/numeric.ops">[numeric.ops]</a>. The goal of this paper is however limited to
adding overloads with <code class="highlight"><c- n>ExecutionPolicy</c-></code> to the existing algorithms in the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> namespace. Any follow-up paper
that adds <code class="highlight"><c- o>&lt;</c-><c- n>numeric</c-><c- o>></c-></code> algorithms to <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> should also consider adding dedicated overloads with <code class="highlight"><c- n>ExecutionPolicy</c-></code>.</p>
   <h2 class="heading settled" data-level="6" id="impl_exp"><span class="secno">6. </span><span class="content">Implementation experience</span><a class="self-link" href="#impl_exp"></a></h2>
   <p>The oneAPI DPC++ Library (oneDPL) <a href="https://oneapi-src.github.io/oneDPL/parallel_api/parallel_range_algorithms.html">developer guide</a> covers parallel range algorithms we’ve implemented so far. The oneAPI specification provides <a href="https://github.com/uxlfoundation/oneAPI-spec/blob/main/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst">formal signatures</a> of these algorithms. The implementation supports execution policies for CPUs (semantically aligned with the C++ standard)
and for SYCL devices, and it works with a subset of the standard C++ views.</p>
   <p>We use the range-as-the-output approach where applicable: in <code class="highlight"><c- n>transform</c-></code>, <code class="highlight"><c- n>copy</c-></code>, <code class="highlight"><c- n>copy_if</c-></code>, and <code class="highlight"><c- n>merge</c-></code>.</p>
   <p>We don’t foresee any issues with implementability for the rest of the proposed parallel algorithms because all of them were
already implemented in C++17 and new APIs that we propose are expressible via the existing ones.</p>
   <h2 class="heading settled" data-level="7" id="further_work"><span class="secno">7. </span><span class="content">Further work</span><a class="self-link" href="#further_work"></a></h2>
   <h3 class="heading settled" data-level="7.1" id="issues_to_address"><span class="secno">7.1. </span><span class="content">Issues to address</span><a class="self-link" href="#issues_to_address"></a></h3>
   <p>Having known bugs and feedback from SG1 and SG9, the plan of work prior to the next committee F2F meeting in
Austria, 2025 is the following:</p>
   <ul>
    <li data-md>
     <p>Update <a href="https://eel.is/c++draft/algorithm.syn">[algorithm.syn]</a>.</p>
    <li data-md>
     <p>Consider adding the algorithm descriptions to the wording, even if no changes are made.</p>
   </ul>
   <h3 class="heading settled" data-level="7.2" id="thread_safe_views"><span class="secno">7.2. </span><span class="content">Thread-safe views examination</span><a class="self-link" href="#thread_safe_views"></a></h3>
   <p>We need to understand better whether using some <code class="highlight"><c- n>views</c-></code> with parallel algorithms might result in data races.
While some investigation was done by other authors in <a data-link-type="biblio" href="#biblio-p3159r0" title="C++ Range Adaptors and Parallel Algorithms">[P3159R0]</a>, it’s mostly not about the data races but about
ability to parallelize processing of data represented by various views.</p>
   <p>We need to invest more time to understand the implications of sharing a state between <code class="highlight"><c- n>view</c-></code> and <code class="highlight"><c- n>iterator</c-></code> on the possibility
of data races. One example is <code class="highlight"><c- n>transform_view</c-></code>, where iterators keep pointers to the function object that is stored
in the view itself.</p>
   <p>Here are questions we want to answer (potentially not a complete list):</p>
   <ul>
    <li data-md>
     <p>Do users have enough control to guarantee absence of data races for such views?</p>
    <li data-md>
     <p>Are races not possible because of implementation strategy chosen by standard libraries?</p>
    <li data-md>
     <p>Do we need to add extra requirements towards thread safety to the standard views?</p>
   </ul>
   <h2 class="heading settled" data-level="8" id="formal_wording"><span class="secno">8. </span><span class="content">Formal wording</span><a class="self-link" href="#formal_wording"></a></h2>
   <h3 class="heading settled" data-level="8.1" id="modify_version_syn"><span class="secno">8.1. </span><span class="content">Add the feature test macro to <a href="http://eel.is/c++draft/version.syn">[<strong>version.syn</strong>]</a></span><a class="self-link" href="#modify_version_syn"></a></h3>
<pre class="wordingStyle highlight"><c- cp>#define __cpp_lib_parallel_algorithm                201603L </c-><c- c1>// also in &lt;algorithm>, &lt;numeric></c-></pre>
   <ins>
<pre class="wordingStyle highlight"><c- cp>#define __cpp_lib_parallel_range_algorithms         20����L </c-><c- c1>// also in &lt;algorithm>, &lt;memory></c-></pre>
   </ins>
<pre class="wordingStyle highlight"><c- cp>#define __cpp_lib_philox_engine                     202406L </c-><c- c1>// also in &lt;random></c-></pre>
   <h3 class="heading settled" data-level="8.2" id="modify_alg_parallel_def"><span class="secno">8.2. </span><span class="content">Modify <a href="https://eel.is/c++draft/algorithms.parallel.defns">[<strong>algorithms.parallel.defns</strong>]</a></span><a class="self-link" href="#modify_alg_parallel_def"></a></h3>
   <p>Parallel algorithms access objects indirectly accessible via their arguments by invoking the following functions:</p>
   <ul>
    <li data-md>
     <p>
      All operations of the categories of the iterators
      <ins>, sentinels</ins>
       or mdspan types that the algorithm is instantiated with.
     </p>
    <li data-md>
     <p>Operations on those sequence elements that are required by its specification.</p>
    <li data-md>
     <p>
      User-provided 
      <del>function</del>
      <ins>invocable</ins>
       objects to be applied during the execution of the algorithm, if required by the specification.
     </p>
    <li data-md>
     <p>
      Operations on those 
      <del>function</del>
      <ins>invocable</ins>
       objects required by the specification.
     </p>
   </ul>
   <h3 class="heading settled" data-level="8.3" id="modify_alg_parallel_user"><span class="secno">8.3. </span><span class="content">Modify <a href="https://eel.is/c++draft/algorithms.parallel.user">[<strong>algorithms.parallel.user</strong>]</a></span><a class="self-link" href="#modify_alg_parallel_user"></a></h3>
   <p>
    Unless otherwise specified, 
    <del>function</del>
    <ins>invocable</ins>
     objects passed into parallel algorithms as objects of type <code class="highlight"><c- n>Predicate</c-></code>, <code class="highlight"><c- n>BinaryPredicate</c-></code>, <code class="highlight"><c- n>Compare</c-></code>, <code class="highlight"><c- n>UnaryOperation</c-></code>, <code class="highlight"><c- n>BinaryOperation</c-></code>, <code class="highlight"><c- n>BinaryOperation1</c-></code>, <code class="highlight"><c- n>BinaryOperation2</c-></code>, <code class="highlight"><c- n>BinaryDivideOp</c-></code>, <span><ins><code class="highlight"><c- n>Proj</c-></code></ins></span> and the operators used by the analogous overloads to these parallel algorithms that are formed by an invocation
with the specified default predicate or operation (where applicable) shall not directly or indirectly modify objects via their arguments,
nor shall they rely on the identity of the provided objects.
   </p>
   <h3 class="heading settled" data-level="8.4" id="modify_alg_parallel_overloads"><span class="secno">8.4. </span><span class="content">Modify <a href="https://eel.is/c++draft/algorithms.parallel.overloads">[<strong>algorithms.parallel.overloads</strong>]</a></span><a class="self-link" href="#modify_alg_parallel_overloads"></a></h3>
   <p>Parallel algorithms shall not participate in overload resolution unless <code class="highlight"><c- n>is_execution_policy_v</c-><c- o>&lt;</c-><c- n>remove_cvref_t</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>>></c-></code> is <code class="highlight">true</code>.</p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>execution</c-><c- o>-</c-><c- n>policy</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
    <c- n>is_execution_policy_v</c-><c- o>&lt;</c-><c- n>remove_cvref_t</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>>></c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.5" id="modify_alg_all_of"><span class="secno">8.5. </span><span class="content">Modify <code class="highlight"><c- n>all_of</c-></code> in <a href="https://eel.is/c++draft/alg.all.of">[<strong>alg.all.of</strong>]</a></span><a class="self-link" href="#modify_alg_all_of"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>all_of</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>all_of</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>all_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>all_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.6" id="modify_alg_any_of"><span class="secno">8.6. </span><span class="content">Modify <code class="highlight"><c- n>any_of</c-></code> in <a href="https://eel.is/c++draft/alg.any.of">[<strong>alg.any.of</strong>]</a></span><a class="self-link" href="#modify_alg_any_of"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>any_of</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>any_of</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>any_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>any_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.7" id="modify_alg_none_of"><span class="secno">8.7. </span><span class="content">Modify <code class="highlight"><c- n>none_of</c-></code> in <a href="https://eel.is/c++draft/alg.none.of">[<strong>alg.none.of</strong>]</a></span><a class="self-link" href="#modify_alg_none_of"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>none_of</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>none_of</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>none_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>none_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.8" id="modify_alg_contains"><span class="secno">8.8. </span><span class="content">Modify <code class="highlight"><c- n>contains</c-></code> in <a href="https://eel.is/c++draft/alg.contains">[<strong>alg.contains</strong>]</a></span><a class="self-link" href="#modify_alg_contains"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><i>Returns</i>: <code class="highlight"><c- n>ranges</c->​<c- o>::</c->​<c- n>find</c-><c- p>(</c-><c- n>std</c->​<c- o>::</c->​<c- n>move</c-><c- p>(</c-><c- n>first</c-><c- p>),</c-> <c- n>last</c-><c- p>,</c-> <c- n>value</c-><c- p>,</c-> <c- n>proj</c-><c- p>)</c-> <c- o>!=</c-> <c- n>last</c-><c- p>.</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
    <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><i>Returns</i>: <code class="highlight"><c- n>ranges</c->​<c- o>::</c->​<c- n>find</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>std</c->​<c- o>::</c->​<c- n>move</c-><c- p>(</c-><c- n>first</c-><c- p>),</c-> <c- n>last</c-><c- p>,</c-> <c- n>value</c-><c- p>,</c-> <c- n>proj</c-><c- p>)</c-> <c- o>!=</c-> <c- n>last</c-><c- p>.</c-></code></p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>forward_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains_subrange</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                                           <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>forward_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains_subrange</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                           <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><i>Returns</i>: <code class="highlight"><c- n>first2</c-> <c- o>==</c-> <c- n>last2</c-> <c- o>||</c-> <c- o>!</c-><c- n>ranges</c->​<c- o>::</c->​<c- n>search</c-><c- p>(</c-><c- n>first1</c-><c- p>,</c-> <c- n>last1</c-><c- p>,</c-> <c- n>first2</c-><c- p>,</c-> <c- n>last2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>).</c-><c- n>empty</c-><c- p>().</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains_subrange</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                                 <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
    <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>contains_subrange</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                 <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><i>Returns</i>: <code class="highlight"><c- n>first2</c-> <c- o>==</c-> <c- n>last2</c-> <c- o>||</c-> <c- o>!</c-><c- n>ranges</c->​<c- o>::</c->​<c- n>search</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>first1</c-><c- p>,</c-> <c- n>last1</c-><c- p>,</c-> <c- n>first2</c-><c- p>,</c-> <c- n>last2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>).</c-><c- n>empty</c-><c- p>().</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.9" id="modify_alg_foreach"><span class="secno">8.9. </span><span class="content">Modify <code class="highlight"><c- n>for_each</c-></code> in <a href="https://eel.is/c++draft/alg.foreach">[<strong>alg.foreach</strong>]</a></span><a class="self-link" href="#modify_alg_foreach"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>for_each_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Fun</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>for_each_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Fun</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Effects</em>: Calls <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>f</c-><c- p>,</c-> <c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>))</c-></code> for every iterator <code class="highlight"><c- n>i</c-></code> in the range <code class="highlight"><c- p>[</c-><c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>)</c-></code>, starting from <code class="highlight"><c- n>first</c-></code> and proceeding to <code class="highlight"><c- n>last</c-> <c- o>-</c-> <c- mi>1</c-></code>.</p>
   <p>[<em>Note x</em>: If the result of <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>)</c-></code> is a mutable reference, <code class="highlight"><c- n>f</c-></code> can apply non-constant functions. — <em>end note</em>]</p>
   <p><em>Returns</em>: <code class="highlight"><c- p>{</c-><c- n>last</c-><c- p>,</c-> <c- n>std</c->​<c- o>::</c->​<c- n>move</c-><c- p>(</c-><c- n>f</c-><c- p>)}.</c-></code></p>
   <p><em>Complexity</em>: Applies <code class="highlight"><c- n>f</c-></code> and <code class="highlight"><c- n>proj</c-></code> exactly <code class="highlight"><c- n>last</c-> <c- o>-</c-> <c- n>first</c-></code> times.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>f</c-></code> returns a result, the result is ignored.</p>
   <p>[<em>Note x</em>: The overloads in namespace <code class="highlight"><c- n>ranges</c-></code> require <code class="highlight"><c- n>Fun</c-></code> to model <code class="highlight"><c- n>copy_constructible</c-></code>. — <em>end note</em>]</p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
    <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>for_each</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Effects</em>: Calls <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>f</c-><c- p>,</c-> <c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>))</c-></code> for every iterator <code class="highlight"><c- n>i</c-></code> in the range <code class="highlight"><c- p>[</c-><c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>)</c-></code>.</p>
    <p>[<em>Note x</em>: If the result of <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>)</c-></code> is a mutable reference, <code class="highlight"><c- n>f</c-></code> can apply non-constant functions. — <em>end note</em>]</p>
    <p><em>Returns</em>: <code class="highlight"><c- n>last</c-><c- p>.</c-></code></p>
    <p><em>Complexity</em>: Applies <code class="highlight"><c- n>f</c-></code> and <code class="highlight"><c- n>proj</c-></code> exactly <code class="highlight"><c- n>last</c-> <c- o>-</c-> <c- n>first</c-></code> times.</p>
    <p><em>Remarks</em>: If <code class="highlight"><c- n>f</c-></code> returns a result, the result is ignored. Implementations do not have the freedom granted under
[algorithms.parallel.exec] to make arbitrary copies of elements from the input sequence.</p>
    <p>[<em>Note x</em>: The overloads in namespace <code class="highlight"><c- n>ranges</c-></code> require <code class="highlight"><c- n>Fun</c-></code> to model <code class="highlight"><c- n>copy_constructible</c-></code>. — <em>end note</em>]</p>
    <p>[<em>Note x</em>: Do not return a copy of its <code class="highlight"><c- n>Fun</c-></code> parameter, since parallelization often does not permit efficient state
accumulation. — <em>end note</em>]</p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>for_each_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Fun</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>for_each_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n>n</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Calls <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>f</c-><c- p>,</c-> <c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>))</c-></code> for every iterator <code class="highlight"><c- n>i</c-></code> in the range <code class="highlight"><c- p>[</c-><c- n>first</c-><c- p>,</c-> <c- n>first</c-> <c- o>+</c-> <c- n>n</c-><c- p>)</c-></code> in order.</p>
   <p>[<em>Note x</em>: If the result of <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>)</c-></code> is a mutable reference, <code class="highlight"><c- n>f</c-></code> can apply non-constant functions. — <em>end note</em>]</p>
   <p>Returns: <code class="highlight"><c- p>{</c-><c- n>first</c-> <c- o>+</c-> <c- n>n</c-><c- p>,</c-> <c- n>std</c->​<c- o>::</c->​<c- n>move</c-><c- p>(</c-><c- n>f</c-><c- p>)}</c-></code>.</p>
   <p>Remarks: If <code class="highlight"><c- n>f</c-></code> returns a result, the result is ignored.</p>
   <p>[<em>Note x</em>: The overload in namespace <code class="highlight"><c- n>ranges</c-></code> requires <code class="highlight"><c- n>Fun</c-></code> to model <code class="highlight"><c- n>copy_constructible</c-></code>. — <em>end note</em>]</p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirectly_unary_invocable</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Fun</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>for_each_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c->
                       <c- n>Fun</c-> <c- n>f</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Preconditions</em>: <code class="highlight"><c- n>n</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>.</p>
    <p><em>Effects</em>: Calls <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>f</c-><c- p>,</c-> <c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>))</c-></code> for every iterator <code class="highlight"><c- n>i</c-></code> in the range <code class="highlight"><c- p>[</c-><c- n>first</c-><c- p>,</c-> <c- n>first</c-> <c- o>+</c-> <c- n>n</c-><c- p>)</c-></code>.</p>
    <p>[<em>Note x</em>: If the result of <code class="highlight"><c- n>invoke</c-><c- p>(</c-><c- n>proj</c-><c- p>,</c-> <c- o>*</c-><c- n>i</c-><c- p>)</c-></code> is a mutable reference, <code class="highlight"><c- n>f</c-></code> can apply non-constant functions. — <em>end note</em>]</p>
    <p>Returns: <code class="highlight"><c- n>first</c-> <c- o>+</c-> <c- n>n</c-></code>.</p>
    <p>Remarks: If <code class="highlight"><c- n>f</c-></code> returns a result, the result is ignored.</p>
    <p>[<em>Note x</em>: The overload in namespace <code class="highlight"><c- n>ranges</c-></code> requires <code class="highlight"><c- n>Fun</c-></code> to model <code class="highlight"><c- n>copy_constructible</c-></code>. — <em>end note</em>]</p>
    <p>[<em>Note x</em>: Does not return a copy of its <code class="highlight"><c- n>Fun</c-></code> parameter, since parallelization often does not permit efficient state
accumulation. — <em>end note</em>]</p>
   </ins>
   <h3 class="heading settled" data-level="8.10" id="modify_alg_find"><span class="secno">8.10. </span><span class="content">Modify <code class="highlight"><c- n>find</c-></code> in <a href="https://eel.is/c++draft/alg.find">[<strong>alg.find</strong>]</a></span><a class="self-link" href="#modify_alg_find"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>find</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>find_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if_not</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>find_if_not</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if_not</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if_not</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.11" id="modify_alg_find_last"><span class="secno">8.11. </span><span class="content">Modify <code class="highlight"><c- n>find_last</c-></code> in <a href="https://eel.is/c++draft/alg.find.last">[<strong>alg.find.last</strong>]</a></span><a class="self-link" href="#modify_alg_find_last"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if_not</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if_not</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if_not</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_last_if_not</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.12" id="modify_alg_find_end"><span class="secno">8.12. </span><span class="content">Modify <code class="highlight"><c- n>find_end</c-></code> in <a href="https://eel.is/c++draft/alg.find.end">[<strong>alg.find.end</strong>]</a></span><a class="self-link" href="#modify_alg_find_end"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>forward_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>find_end</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>forward_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>find_end</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c->
         <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_end</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                                <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
             <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_end</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                                           <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.13" id="modify_alg_find_first_of"><span class="secno">8.13. </span><span class="content">Modify <code class="highlight"><c- n>find_first_of</c-></code> in <a href="https://eel.is/c++draft/alg.find.first.of">[<strong>alg.find.first.of</strong>]</a></span><a class="self-link" href="#modify_alg_find_first_of"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>forward_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I1</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_first_of</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                                     <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>forward_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>find_first_of</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                          <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                          <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>I1</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_first_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                           <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
             <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_first_of</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                                                <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.14" id="modify_alg_adjacent_find"><span class="secno">8.14. </span><span class="content">Modify <code class="highlight"><c- n>adjacent_find</c-></code> in <a href="https://eel.is/c++draft/alg.adjacent.find">[<strong>alg.adjacent.find</strong>]</a></span><a class="self-link" href="#modify_alg_adjacent_find"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
                                   <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>adjacent_find</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
                                   <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>adjacent_find</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>adjacent_find</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c->
           <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>adjacent_find</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.15" id="modify_alg_count"><span class="secno">8.15. </span><span class="content">Modify <code class="highlight"><c- n>count</c-></code> in <a href="https://eel.is/c++draft/alg.count">[<strong>alg.count</strong>]</a></span><a class="self-link" href="#modify_alg_count"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>count</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>count</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>count</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>count</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>count_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>count_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>count_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>count_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.16" id="modify_alg_mismatch"><span class="secno">8.16. </span><span class="content">Modify <code class="highlight"><c- n>mismatch</c-></code> in <a href="https://eel.is/c++draft/alg.mismatch">[<strong>alg.mismatch</strong>]</a></span><a class="self-link" href="#modify_alg_mismatch"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>mismatch_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>mismatch_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>mismatch_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-><c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                     <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>mismatch_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.17" id="modify_alg_equal"><span class="secno">8.17. </span><span class="content">Modify <code class="highlight"><c- n>equal</c-></code> in <a href="https://eel.is/c++draft/alg.equal">[<strong>alg.equal</strong>]</a></span><a class="self-link" href="#modify_alg_equal"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                               <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                               <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                               <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                     <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
    <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                     <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.18" id="modify_alg_search"><span class="secno">8.18. </span><span class="content">Modify <code class="highlight"><c- n>search</c-></code> in <a href="https://eel.is/c++draft/alg.search">[<strong>alg.search</strong>]</a></span><a class="self-link" href="#modify_alg_search"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>forward_iterator</c-> <c- n>I2</c-><c- p>,</c->
         <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>search</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                   <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>forward_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>search</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                   <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
    <c- n>subrange</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c->
      <c- n>ranges</c-><c- o>::</c-><c- n>search</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                     <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
           <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
    <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c->
      <c- n>ranges</c-><c- o>::</c-><c- n>search</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                     <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>search_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>count</c-><c- p>,</c->
                     <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>search_n</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>count</c-><c- p>,</c->
                     <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
    <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
      <c- n>ranges</c-><c- o>::</c-><c- n>search_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>count</c-><c- p>,</c->
                       <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
           <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
      <c- n>ranges</c-><c- o>::</c-><c- n>search_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>count</c-><c- p>,</c->
                       <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.19" id="modify_alg_starts_with"><span class="secno">8.19. </span><span class="content">Modify <code class="highlight"><c- n>starts_with</c-></code> in <a href="https://eel.is/c++draft/alg.starts.with">[<strong>alg.starts.with</strong>]</a></span><a class="self-link" href="#modify_alg_starts_with"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>starts_with</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>starts_with</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><i>Returns</i>: <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first1</c-><c- p>),</c-> <c- n>last1</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first2</c-><c- p>),</c-> <c- n>last2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>).</c-><c- n>in2</c-> <c- o>==</c-> <c- n>last2</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>starts_with</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                           <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
    <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>starts_with</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><i>Returns</i>: <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>mismatch</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first1</c-><c- p>),</c-> <c- n>last1</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first2</c-><c- p>),</c-> <c- n>last2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>).</c-><c- n>in2</c-> <c- o>==</c-> <c- n>last2</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.20" id="modify_alg_ends_with"><span class="secno">8.20. </span><span class="content">Modify <code class="highlight"><c- n>ends_with</c-></code> in <a href="https://eel.is/c++draft/alg.ends.with">[<strong>alg.ends.with</strong>]</a></span><a class="self-link" href="#modify_alg_ends_with"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- p>(</c-><c- n>forward_iterator</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- o>||</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>S1</c-><c- p>,</c-> <c- n>I1</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c->
           <c- p>(</c-><c- n>forward_iterator</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- o>||</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>S2</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>ends_with</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                   <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p>Let <code class="highlight"><c- n>N1</c-></code> be <code class="highlight"><c- n>last1</c-> <c- o>-</c-> <c- n>first1</c-></code> and <code class="highlight"><c- n>N2</c-></code> be <code class="highlight"><c- n>last2</c-> <c- o>-</c-> <c- n>first2</c-></code>.</p>
   <p><i>Returns</i>: <code class="highlight">false</code> if <code class="highlight"><c- n>N1</c-> <c- o>&lt;</c-> <c- n>N2</c-></code>, otherwise <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first1</c-><c- p>)</c-> <c- o>+</c-> <c- p>(</c-><c- n>N1</c-> <c- o>-</c-> <c- n>N2</c-><c- p>),</c-> <c- n>last1</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first2</c-><c- p>),</c-> <c- n>last2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>)</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>ends_with</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                         <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p>Let <code class="highlight"><c- n>N1</c-></code> be <code class="highlight"><c- n>last1</c-> <c- o>-</c-> <c- n>first1</c-></code> and <code class="highlight"><c- n>N2</c-></code> be <code class="highlight"><c- n>last2</c-> <c- o>-</c-> <c- n>first2</c-></code>.</p>
    <p><i>Returns</i>: <code class="highlight">false</code> if <code class="highlight"><c- n>N1</c-> <c- o>&lt;</c-> <c- n>N2</c-></code>, otherwise <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first1</c-><c- p>)</c-> <c- o>+</c-> <c- p>(</c-><c- n>N1</c-> <c- o>-</c-> <c- n>N2</c-><c- p>),</c-> <c- n>last1</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>first2</c-><c- p>),</c-> <c- n>last2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>)</c-></code></p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- p>(</c-><c- n>forward_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>||</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c->
           <c- p>(</c-><c- n>forward_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>||</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>ends_with</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c->
                                   <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p>Let <code class="highlight"><c- n>N1</c-></code> be <code class="highlight"><c- n>ranges</c->​<c- o>::</c->​<c- n>distance</c-><c- p>(</c-><c- n>r1</c-><c- p>)</c-></code> and <code class="highlight"><c- n>N2</c-></code> be <code class="highlight"><c- n>ranges</c->​<c- o>::</c->​<c- n>distance</c-><c- p>(</c-><c- n>r2</c-><c- p>)</c-></code>.</p>
   <p><i>Returns</i>: <code class="highlight">false</code> if <code class="highlight"><c- n>N1</c-> <c- o>&lt;</c-> <c- n>N2</c-></code>, otherwise <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>views</c-><c- o>::</c-><c- n>drop</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>ref_view</c-><c- p>(</c-><c- n>r1</c-><c- p>),</c-> <c- n>N1</c-> <c- o>-</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- n>N1</c-><c- p>)</c-><c- o>></c-><c- p>(</c-><c- n>N2</c-><c- p>)),</c-> <c- n>r2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>)</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Pred</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- p>(</c-><c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_comparable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>ends_with</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                         <c- n>Pred</c-> <c- n>pred</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p>Let <code class="highlight"><c- n>N1</c-></code> be <code class="highlight"><c- n>ranges</c->​<c- o>::</c->​<c- n>distance</c-><c- p>(</c-><c- n>r1</c-><c- p>)</c-></code> and <code class="highlight"><c- n>N2</c-></code> be <code class="highlight"><c- n>ranges</c->​<c- o>::</c->​<c- n>distance</c-><c- p>(</c-><c- n>r2</c-><c- p>)</c-></code>.</p>
    <p><i>Returns</i>: <code class="highlight">false</code> if <code class="highlight"><c- n>N1</c-> <c- o>&lt;</c-> <c- n>N2</c-></code>, otherwise <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>equal</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>,</c-> <c- n>views</c-><c- o>::</c-><c- n>drop</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>ref_view</c-><c- p>(</c-><c- n>r1</c-><c- p>),</c-> <c- n>N1</c-> <c- o>-</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- n>N1</c-><c- p>)</c-><c- o>></c-><c- p>(</c-><c- n>N2</c-><c- p>)),</c-> <c- n>r2</c-><c- p>,</c-> <c- n>pred</c-><c- p>,</c-> <c- n>proj1</c-><c- p>,</c-> <c- n>proj2</c-><c- p>)</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.21" id="modify_copy"><span class="secno">8.21. </span><span class="content">Modify <code class="highlight"><c- n>copy</c-></code> in <a href="https://eel.is/c++draft/alg.copy">[<strong>alg.copy</strong>]</a></span><a class="self-link" href="#modify_copy"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>ForwardIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>ForwardIterator2</c-><c- o>></c->
  <c- n>ForwardIterator2</c-> <c- n>copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>policy</c-><c- p>,</c->
                        <c- n>ForwardIterator1</c-> <c- n>first</c-><c- p>,</c-> <c- n>ForwardIterator1</c-> <c- n>last</c-><c- p>,</c->
                        <c- n>ForwardIterator2</c-> <c- n>result</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>copy_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>O</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>copy_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>copy_if_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>copy_if_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>copy_if_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                    <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>copy_if_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>copy_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.22" id="modify_move"><span class="secno">8.22. </span><span class="content">Modify <code class="highlight"><c- n>move</c-></code> in <a href="https://eel.is/c++draft/alg.move">[<strong>alg.move</strong>]</a></span><a class="self-link" href="#modify_move"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>ForwardIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>ForwardIterator2</c-><c- o>></c->
  <c- n>ForwardIterator2</c-> <c- n>move</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>policy</c-><c- p>,</c->
                        <c- n>ForwardIterator1</c-> <c- n>first</c-><c- p>,</c-> <c- n>ForwardIterator1</c-> <c- n>last</c-><c- p>,</c->
                        <c- n>ForwardIterator2</c-> <c- n>result</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_movable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>move_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_movable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>move_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>);</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.23" id="modify_swap"><span class="secno">8.23. </span><span class="content">Modify <code class="highlight"><c- n>swap</c-></code> in <a href="https://eel.is/c++draft/alg.swap">[<strong>alg.swap</strong>]</a></span><a class="self-link" href="#modify_swap"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_swappable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_swappable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_swappable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_swappable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>swap_ranges</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>);</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.24" id="modify_transform"><span class="secno">8.24. </span><span class="content">Modify <code class="highlight"><c- n>transform</c-></code> in <a href="https://eel.is/c++draft/alg.transform">[<strong>alg.transform</strong>]</a></span><a class="self-link" href="#modify_transform"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>unary_transform_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>I</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S</c-> <c- n>last1</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>F</c-> <c- n>op</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>unary_transform_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>F</c-> <c- n>op</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>unary_transform_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                      <c- n>F</c-> <c- n>op</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>>></c->
           <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>unary_transform_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c-> <c- n>F</c-> <c- n>op</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                         <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>binary_transform_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                      <c- n>F</c-> <c- n>binary_op</c-><c- p>,</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                         <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>binary_transform_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                      <c- n>F</c-> <c- n>binary_op</c-><c- p>,</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c->  <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>binary_transform_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                      <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c-> <c- n>F</c-> <c- n>binary_op</c-><c- p>,</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- n>copy_constructible</c-> <c- n>F</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c->
             <c- n>indirect_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>binary_transform_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                      <c- n>F</c-> <c- n>binary_op</c-><c- p>,</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.25" id="modify_replace"><span class="secno">8.25. </span><span class="content">Modify <code class="highlight"><c- n>replace</c-></code> in <a href="https://eel.is/c++draft/alg.replace">[<strong>alg.replace</strong>]</a></span><a class="self-link" href="#modify_replace"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>T1</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>I</c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>T1</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>T1</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c->
                    <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>T1</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c->
                    <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c->
                       <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c->
                       <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
           <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c->
                         <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c->
           <c- o>&amp;&amp;</c-> <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c->
                         <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c-><c- p>,</c-> 
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                         <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T1</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T2</c-> <c- o>=</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T1</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                         <c- k>const</c-> <c- n>T1</c-><c- o>&amp;</c-> <c- n>old_value</c-><c- p>,</c-> <c- k>const</c-> <c- n>T2</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-><c- k>class</c-> <c- nc>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c->
                            <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c->
                            <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                            <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>replace_copy_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                            <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>new_value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.26" id="modify_fill"><span class="secno">8.26. </span><span class="content">Modify <code class="highlight"><c- n>fill</c-></code> in <a href="https://eel.is/c++draft/alg.fill">[<strong>alg.fill</strong>]</a></span><a class="self-link" href="#modify_fill"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>O</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>fill</c-><c- p>(</c-><c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>output_range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>fill</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- k>constexpr</c-> <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>fill_n</c-><c- p>(</c-><c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>output_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>fill</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>output_range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>fill</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c->
    <c- k>requires</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
  <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>fill_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>);</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.27" id="modify_generate"><span class="secno">8.27. </span><span class="content">Modify <code class="highlight"><c- n>generate</c-></code> in <a href="https://eel.is/c++draft/alg.generate">[<strong>alg.generate</strong>]</a></span><a class="self-link" href="#modify_generate"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_or_output_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- o>></c->
  <c- k>requires</c-> <c- n>invocable</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>invoke_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;>></c->
  <c- k>constexpr</c-> <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>generate</c-><c- p>(</c-><c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>F</c-> <c- n>gen</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- o>></c->
  <c- k>requires</c-> <c- n>invocable</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>output_range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>invoke_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>generate</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>F</c-> <c- n>gen</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_or_output_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- o>></c->
  <c- k>requires</c-> <c- n>invocable</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>invoke_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;>></c->
  <c- k>constexpr</c-> <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>generate_n</c-><c- p>(</c-><c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- n>F</c-> <c- n>gen</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- o>></c->
  <c- k>requires</c-> <c- n>invocable</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>invoke_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;>></c->
  <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>generate</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>F</c-> <c- n>gen</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- o>></c->
  <c- k>requires</c-> <c- n>invocable</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>output_range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>invoke_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>generate</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>F</c-> <c- n>gen</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>copy_constructible</c-> <c- n>F</c-><c- o>></c->
  <c- k>requires</c-> <c- n>invocable</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_writable</c-><c- o>&lt;</c-><c- n>O</c-><c- p>,</c-> <c- n>invoke_result_t</c-><c- o>&lt;</c-><c- n>F</c-><c- o>&amp;>></c->
  <c- n>O</c-> <c- n>ranges</c-><c- o>::</c-><c- n>generate_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>O</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- n>F</c-> <c- n>gen</c-><c- p>);</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.28" id="modify_remove"><span class="secno">8.28. </span><span class="content">Modify <code class="highlight"><c- n>remove</c-></code> in <a href="https://eel.is/c++draft/alg.remove">[<strong>alg.remove</strong>]</a></span><a class="self-link" href="#modify_remove"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->  <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                        <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>T</c-> <c- o>=</c-> <c- n>projected_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_binary_predicate</c-><c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>*></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                           <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>remove_copy_if</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.29" id="modify_unique"><span class="secno">8.29. </span><span class="content">Modify <code class="highlight"><c- n>unique</c-></code> in <a href="https://eel.is/c++draft/alg.unique">[<strong>alg.unique</strong>]</a></span><a class="self-link" href="#modify_unique"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>unique</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>unique</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>unique</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>unique</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- p>(</c-><c- n>forward_iterator</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- o>||</c->
            <c- p>(</c-><c- n>input_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>same_as</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-><c- p>,</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c-><c- p>)</c-> <c- o>||</c->
            <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-><c- p>)</c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- p>(</c-><c- n>forward_iterator</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>||</c->
            <c- p>(</c-><c- n>input_iterator</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>same_as</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>>></c-><c- p>)</c-> <c- o>||</c->
            <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c-><c- p>)</c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                        <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_equivalence_relation</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>C</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>equal_to</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>unique_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                        <c- n>C</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.30" id="modify_reverse"><span class="secno">8.30. </span><span class="content">Modify <code class="highlight"><c- n>reverse</c-></code> in <a href="https://eel.is/c++draft/alg.reverse">[<strong>alg.reverse</strong>]</a></span><a class="self-link" href="#modify_reverse"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>reverse</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>reverse</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>reverse</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>reverse</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>);</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>reverse_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>);</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.31" id="modify_rotate"><span class="secno">8.31. </span><span class="content">Modify <code class="highlight"><c- n>rotate</c-></code> in <a href="https://eel.is/c++draft/alg.rotate">[<strong>alg.rotate</strong>]</a></span><a class="self-link" href="#modify_rotate"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>);</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>rotate</c-><c- p>(</c-><c- n>ranges</c->​<c- o>::</c->​<c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>));</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>);</c->
</pre>
    <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>rotate</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>));</c-></code></p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- o>></c->
    <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>);</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>result</c-><c- p>));</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>);</c->
</pre>
    <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>rotate_copy</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>result</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>result</c-><c- p>));</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.32" id="modify_shift"><span class="secno">8.32. </span><span class="content">Modify <code class="highlight"><c- n>shift</c-></code> in <a href="https://eel.is/c++draft/alg.shift">[<strong>alg.shift</strong>]</a></span><a class="self-link" href="#modify_shift"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_left</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_left</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>n</c-><c- p>)</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_left</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_left</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_right</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_right</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_right</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>shift_right</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.33" id="modify_sort"><span class="secno">8.33. </span><span class="content">Modify <code class="highlight"><c- n>sort</c-></code> in <a href="https://eel.is/c++draft/sort">[<strong>sort</strong>]</a></span><a class="self-link" href="#modify_sort"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c->
    <c- n>ranges</c-><c- o>::</c-><c- n>sort</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>sort</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>sort</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>sort</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.34" id="modify_stable_sort"><span class="secno">8.34. </span><span class="content">Modify <code class="highlight"><c- n>stable_sort</c-></code> in <a href="https://eel.is/c++draft/stable.sort">[<strong>stable.sort</strong>]</a></span><a class="self-link" href="#modify_stable_sort"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_sort</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>stable_sort</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_sort</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_sort</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.35" id="modify_partial_sort"><span class="secno">8.35. </span><span class="content">Modify <code class="highlight"><c- n>partial_sort</c-></code> in <a href="https://eel.is/c++draft/partial.sort">[<strong>partial.sort</strong>]</a></span><a class="self-link" href="#modify_partial_sort"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>,</c->
                                              <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Effects</em>: Equivalent to:<br> <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.36" id="modify_partial_sort_copy"><span class="secno">8.36. </span><span class="content">Modify <code class="highlight"><c- n>partial_sort_copy</c-></code> in <a href="https://eel.is/c++draft/partial.sort.copy">[<strong>partial.sort.copy</strong>]</a></span><a class="self-link" href="#modify_partial_sort_copy"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>Comp</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy</c-><c- p>(</c-><c- n>I1</c-> <c- n>first</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last</c-><c- p>,</c-> <c- n>I2</c-> <c- n>result_first</c-><c- p>,</c-> <c- n>S2</c-> <c- n>result_last</c-><c- p>,</c->
                              <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>Comp</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                      <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>result_r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                              <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>Comp</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last</c-><c- p>,</c-> <c- n>I2</c-> <c- n>result_first</c-><c- p>,</c-> <c- n>S2</c-> <c- n>result_last</c-><c- p>,</c->
                              <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>Comp</c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                      <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partial_sort_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>result_r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                              <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.37" id="modify_is_sorted"><span class="secno">8.37. </span><span class="content">Modify <code class="highlight"><c- n>is_sorted</c-></code> in <a href="https://eel.is/c++draft/is.sorted">[<strong>is.sorted</strong>]</a></span><a class="self-link" href="#modify_is_sorted"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>is_sorted_until</c-><c- p>(</c-><c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>,</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>)</c-> <c- o>==</c-> <c- n>last</c-><c- p>;</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Effects</em>: Equivalent to:<br> <code class="highlight"><c- k>return</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>is_sorted_until</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>,</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>)</c-> <c- o>==</c-> <c- n>last</c-><c- p>;</c-></code></p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted_until</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted_until</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted_until</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_sorted_until</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.38" id="modify_nth_element"><span class="secno">8.38. </span><span class="content">Modify <code class="highlight"><c- n>nth_element</c-></code> in <a href="https://eel.is/c++draft/alg.nth.element">[<strong>alg.nth.element</strong>]</a></span><a class="self-link" href="#modify_nth_element"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c->
    <c- n>ranges</c-><c- o>::</c-><c- n>nth_element</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>nth</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>nth_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>nth</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>nth_element</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>nth</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>nth_element</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>nth</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>nth_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>nth</c-><c- p>,</c->
                                             <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>nth_element</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>nth</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.39" id="modify_partitions"><span class="secno">8.39. </span><span class="content">Modify <code class="highlight"><c- n>partitions</c-></code> in <a href="https://eel.is/c++draft/alg.partitions">[<strong>alg.partitions</strong>]</a></span><a class="self-link" href="#modify_partitions"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_partitioned</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_partitioned</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_partitioned</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_partitioned</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>permutable</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partition</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partition</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>partition</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>partition</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_partition</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
  <c- k>constexpr</c-> <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_partition</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
  <c- n>subrange</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_partition</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>permutable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_subrange_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>stable_partition</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O1</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O1</c-><c- p>,</c-> <c- n>O2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O1</c-> <c- n>out_true</c-><c- p>,</c-> <c- n>O2</c-> <c- n>out_false</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c->
                           <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O1</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O1</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>O1</c-><c- p>,</c-> <c- n>O2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>O1</c-> <c- n>out_true</c-><c- p>,</c-> <c- n>O2</c-> <c- n>out_false</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O1</c-><c- o>></c-> <c- n>OutS1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O2</c-><c- o>></c-> <c- n>OutS2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O1</c-><c- p>,</c-> <c- n>O2</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>O1</c-> <c- n>out_true</c-><c- p>,</c-> <c- n>OutS1</c-> <c- n>last_true</c-><c- p>,</c->
                           <c- n>O2</c-> <c- n>out_false</c-><c- p>,</c-> <c- n>OutS2</c-> <c- n>last_false</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR1</c-><c- p>,</c->
         <c- n>random_access_range</c-> <c- n>OutR2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_unary_predicate</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Pred</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR1</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>indirectly_copyable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR2</c-><c- o>>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR2</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>partition_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>OutR1</c-><c- o>&amp;&amp;</c-> <c- n>out_true</c-><c- p>,</c-> <c- n>OutR2</c-><c- o>&amp;&amp;</c-> <c- n>out_false</c-><c- p>,</c->
                           <c- n>Pred</c-> <c- n>pred</c-><c- p>,</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.40" id="modify_merge"><span class="secno">8.40. </span><span class="content">Modify <code class="highlight"><c- n>merge</c-></code> in <a href="https://eel.is/c++draft/alg.merge">[<strong>alg.merge</strong>]</a></span><a class="self-link" href="#modify_merge"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>merge_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>merge</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                  <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>merge_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>merge</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                  <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>merge_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>merge</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c->
                  <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                  <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c->
         <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>merge_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>merge</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                  <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>inplace_merge</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>inplace_merge</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>I</c-> <c- n>middle</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>bidirectional_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>inplace_merge</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>inplace_merge</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sortable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>ranges</c-><c- o>::</c-><c- n>inplace_merge</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>middle</c-><c- p>,</c->
                                               <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Effects</em>: Equivalent to:<br> <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>inplace_merge</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>middle</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>);</c-></code></p>
   </ins>
   <h3 class="heading settled" data-level="8.41" id="modify_includes"><span class="secno">8.41. </span><span class="content">Modify <code class="highlight"><c- n>includes</c-></code> in <a href="https://eel.is/c++draft/includes">[<strong>includes</strong>]</a></span><a class="self-link" href="#modify_includes"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                    <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>includes</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                                  <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                    <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>includes</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                                  <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>includes</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                        <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>includes</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c->
                        <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.42" id="modify_set_union"><span class="secno">8.42. </span><span class="content">Modify <code class="highlight"><c- n>set_union</c-></code> in <a href="https://eel.is/c++draft/set.union">[<strong>set.union</strong>]</a></span><a class="self-link" href="#modify_set_union"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_union_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_union</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                      <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_union_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_union</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                      <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_union_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_union</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c->
                      <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                      <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_union_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_union</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                      <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.43" id="modify_set_intersection"><span class="secno">8.43. </span><span class="content">Modify <code class="highlight"><c- n>set_intersection</c-></code> in <a href="https://eel.is/c++draft/set.intersection">[<strong>set.intersection</strong>]</a></span><a class="self-link" href="#modify_set_intersection"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                             <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                             <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c->
                             <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                             <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_intersection</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                             <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.44" id="modify_set_difference"><span class="secno">8.44. </span><span class="content">Modify <code class="highlight"><c- n>set_difference</c-></code> in <a href="https://eel.is/c++draft/set.difference">[<strong>set.difference</strong>]</a></span><a class="self-link" href="#modify_set_difference"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_difference_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_difference</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                           <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_difference_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_difference</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                           <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_difference_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_difference</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c->
                           <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                           <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_difference_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_difference</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                           <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.45" id="modify_set_symmetric_difference"><span class="secno">8.45. </span><span class="content">Modify <code class="highlight"><c- n>set_symmetric_difference</c-></code> in <a href="https://eel.is/c++draft/set.symmetric.difference">[<strong>set.symmetric.difference</strong>]</a></span><a class="self-link" href="#modify_set_symmetric_difference"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c->
                                     <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c->
                                     <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>weakly_incrementable</c-> <c- n>O</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c->
                                                    <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                                     <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>O</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>OutS</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference_result</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>I2</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c->
                                     <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c-> <c- n>O</c-> <c- n>result</c-><c- p>,</c-> <c- n>OutS</c-> <c- n>result_last</c-><c- p>,</c->
                                     <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>OutR</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- o>></c->
  <c- k>requires</c-> <c- n>mergeable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c-><c- p>,</c-> <c- n>Comp</c-><c- p>,</c-> <c- n>Proj1</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>></c-> <c- o>&amp;&amp;</c->
           <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OutR</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>set_symmetric_difference</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>OutR</c-><c- o>&amp;&amp;</c-> <c- n>result</c-><c- p>,</c->
                                      <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.46" id="modify_is_heap"><span class="secno">8.46. </span><span class="content">Modify <code class="highlight"><c- n>is_heap</c-></code> in <a href="https://eel.is/c++draft/is.heap">[<strong>is.heap</strong>]</a></span><a class="self-link" href="#modify_is_heap"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_heap</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_heap</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>is_heap_until</c-><c- p>(</c-><c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>,</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>)</c-> <c- o>==</c-> <c- n>last</c-><c- p>;</c-></code></p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_heap</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_heap</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
    <p><em>Effects</em>: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>ranges</c->​<c- o>::</c->​<c- n>is_heap_until</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>ExecutionPolicy</c-><c- o>></c-><c- p>(</c-><c- n>exec</c-><c- p>),</c-> <c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>,</c-> <c- n>comp</c-><c- p>,</c-> <c- n>proj</c-><c- p>)</c-> <c- o>==</c-> <c- n>last</c-><c- p>;</c-></code></p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_heap_until</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>is_heap_until</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>is_heap_until</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>is_heap_until</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

</pre>
   </ins>
   <h3 class="heading settled" data-level="8.47" id="modify_alg_min_max"><span class="secno">8.47. </span><span class="content">Modify <code class="highlight"><c- n>min</c-></code>, <code class="highlight"><c- n>max</c-></code>, <code class="highlight"><c- n>minmax</c-></code> in <a href="https://eel.is/c++draft/alg.min.max">[<strong>alg.min.max</strong>]</a></span><a class="self-link" href="#modify_alg_min_max"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>*></c->
  <c- k>constexpr</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>min</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>*></c->
  <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>min</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>*></c->
  <c- k>constexpr</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>max</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>*></c->
  <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>max</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>*></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>minmax_result</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>minmax</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>indirectly_copyable_storable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>*></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>minmax_result</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>minmax</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>min_element</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>min_element</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>min_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>min_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>max_element</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>max_element</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- n>I</c-> <c- n>ranges</c-><c- o>::</c-><c- n>max_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>max_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>forward_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element_result</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>forward_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element_result</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Proj</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- n>ranges</c-><c- o>::</c-><c- n>minmax_element</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj</c-> <c- n>proj</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.48" id="modify_alg_lex_comparison"><span class="secno">8.48. </span><span class="content">Modify <code class="highlight"><c- n>lexicographical_compare</c-></code> in <a href="https://eel.is/c++draft/alg.lex.comparison">[<strong>alg.lex.comparison</strong>]</a></span><a class="self-link" href="#modify_alg_lex_comparison"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c-> <c- n>input_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                    <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c->
    <c- n>ranges</c-><c- o>::</c-><c- n>lexicographical_compare</c-><c- p>(</c-><c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                                    <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>input_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                    <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>constexpr</c-> <c- b>bool</c->
    <c- n>ranges</c-><c- o>::</c-><c- n>lexicographical_compare</c-><c- p>(</c-><c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                                    <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I1</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I1</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <c- n>random_access_iterator</c-> <c- n>I2</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I2</c-><c- o>></c-> <c- n>S2</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>I1</c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c-> <c- n>projected</c-><c- o>&lt;</c-><c- n>I2</c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>lexicographical_compare</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I1</c-> <c- n>first1</c-><c- p>,</c-> <c- n>S1</c-> <c- n>last1</c-><c- p>,</c-> <c- n>I2</c-> <c- n>first2</c-><c- p>,</c-> <c- n>S2</c-> <c- n>last2</c-><c- p>,</c->
                                       <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R1</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>R2</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Proj1</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>Proj2</c-> <c- o>=</c-> <c- n>identity</c-><c- p>,</c->
         <c- n>indirect_strict_weak_order</c-><c- o>&lt;</c-><c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-><c- p>,</c-> <c- n>Proj1</c-><c- o>></c-><c- p>,</c->
                                    <c- n>projected</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c-><c- p>,</c-> <c- n>Proj2</c-><c- o>>></c-> <c- n>Comp</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>less</c-><c- o>></c->
  <c- k>requires</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R1</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R2</c-><c- o>></c->
  <c- b>bool</c-> <c- n>ranges</c-><c- o>::</c-><c- n>lexicographical_compare</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R1</c-><c- o>&amp;&amp;</c-> <c- n>r1</c-><c- p>,</c-> <c- n>R2</c-><c- o>&amp;&amp;</c-> <c- n>r2</c-><c- p>,</c-> <c- n>Comp</c-> <c- n>comp</c-> <c- o>=</c-> <c- p>{},</c->
                                       <c- n>Proj1</c-> <c- n>proj1</c-> <c- o>=</c-> <c- p>{},</c-> <c- n>Proj2</c-> <c- n>proj2</c-> <c- o>=</c-> <c- p>{});</c->
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.49" id="modify_memory_syn"><span class="secno">8.49. </span><span class="content">Modify <a href="https://eel.is/c++draft/memory.syn">[<strong>memory.syn</strong>]</a></span><a class="self-link" href="#modify_memory_syn"></a></h3>
<pre class="highlight"><i><c- c1>// [specialized.algorithms], specialized algorithms</c-></i>
<i><c- c1>// [special.mem.concepts], special memory concepts</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->       <i><c- c1>// exposition only</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->     <i><c- c1>// exposition only</c-></i>
<ins>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->  <i><c- c1>// exposition only</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->  <i><c- c1>// exposition only</c-></i>
</ins>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->         <i><c- c1>// exposition only</c-></i>
<ins>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->   <i><c- c1>// exposition only</c-></i>
</ins>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->          <i><c- c1>// exposition only</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->        <i><c- c1>// exposition only</c-></i>
<ins>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->     <i><c- c1>// exposition only</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
  <c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->     <i><c- c1>// exposition only</c-></i>
</ins>
</pre>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>I</c-> <c- n>uninitialized_default_construct</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c->                         <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>uninitialized_default_construct</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>);</c->              <i><c- c1>// freestanding</c-></i>

<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>I</c-> <c- n>uninitialized_default_construct_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->       <i><c- c1>// freestanding</c-></i>
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
  <c- n>I</c-> <c- n>uninitialized_default_construct</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>uninitialized_default_construct</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
  <c- n>I</c-> <c- n>uninitialized_default_construct_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>I</c-> <c- n>uninitialized_value_construct</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c->                           <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>uninitialized_value_construct</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>);</c->                <i><c- c1>// freestanding</c-></i>

<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>I</c-> <c- n>uninitialized_value_construct_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c->         <i><c- c1>// freestanding</c-></i>
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-><c- o>&lt;</c-></i><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
  <c- n>I</c-> <c- n>uninitialized_value_construct</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
  <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>uninitialized_value_construct</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
  <c- k>requires</c-> <c- n>default_initializable</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
  <c- n>I</c-> <c- n>uninitialized_value_construct_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
          <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_copy</c-><c- p>(</c-><c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>S1</c-> <c- n>ilast</c-><c- p>,</c-> <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S2</c-> <c- n>olast</c-><c- p>);</c->               <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>IR</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- n>OR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c-><c- p>,</c-> <c- n>range_reference_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>>></c->
    <c- n>uninitialized_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>>></c->
      <c- n>uninitialized_copy</c-><c- p>(</c-><c- n>IR</c-><c- o>&amp;&amp;</c-> <c- n>in_range</c-><c- p>,</c-> <c- n>OR</c-><c- o>&amp;&amp;</c-> <c- n>out_range</c-><c- p>);</c->                        <i><c- c1>// freestanding</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>O</c-><c- o>></c->
  <c- k>using</c-> <c- n>uninitialized_copy_n_result</c-> <c- o>=</c-> <c- n>in_out_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-><c- p>;</c->                      <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_copy_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_copy_n</c-><c- p>(</c-><c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c->                    <i><c- c1>// freestanding</c-></i>
                           <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S</c-> <c- n>olast</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_copy_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>S1</c-> <c- n>ilast</c-><c- p>,</c-> <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S2</c-> <c- n>olast</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>IR</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- n>OR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c-><c- p>,</c-> <c- n>range_reference_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c->
    <c- n>uninitialized_copy_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>>></c->
      <c- n>uninitialized_copy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>IR</c-><c- o>&amp;&amp;</c-> <c- n>in_range</c-><c- p>,</c-> <c- n>OR</c-><c- o>&amp;&amp;</c-> <c- n>out_range</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c->
         <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_copy_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_copy_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
                           <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S</c-> <c- n>olast</c-><c- p>);</c->
</pre>
   </ins>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
          <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_move_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_move</c-><c- p>(</c-><c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>S1</c-> <c- n>ilast</c-><c- p>,</c-> <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S2</c-> <c- n>olast</c-><c- p>);</c->              <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>IR</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- n>OR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c-><c- p>,</c-> <c- n>range_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>>></c->
    <c- n>uninitialized_move_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>>></c->
      <c- n>uninitialized_move</c-><c- p>(</c-><c- n>IR</c-><c- o>&amp;&amp;</c-> <c- n>in_range</c-><c- p>,</c-> <c- n>OR</c-><c- o>&amp;&amp;</c-> <c- n>out_range</c-><c- p>);</c->                       <i><c- c1>// freestanding</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c->
          <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_move_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_move_n</c-><c- p>(</c-><c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c->                <i><c- c1>// freestanding</c-></i>
                           <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S</c-> <c- n>olast</c-><c- p>);</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
         <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_move_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_move</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>S1</c-> <c- n>ilast</c-><c- p>,</c-> <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S2</c-> <c- n>olast</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_range</c-> <c- n>IR</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- n>OR</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c-><c- p>,</c-> <c- n>range_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c->
    <c- n>uninitialized_move_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>>></c->
      <c- n>uninitialized_move</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>IR</c-><c- o>&amp;&amp;</c-> <c- n>in_range</c-><c- p>,</c-> <c- n>OR</c-><c- o>&amp;&amp;</c-> <c- n>out_range</c-><c- p>);</c->        <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <c- n>random_access_iterator</c-> <c- n>I</c-><c- p>,</c->
    <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>uninitialized_move_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
      <c- n>uninitialized_move_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
                           <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S</c-> <c- n>olast</c-><c- p>);</c->
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
    <c- n>I</c-> <c- n>uninitialized_fill</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->                          <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
    <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>uninitialized_fill</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->               <i><c- c1>// freestanding</c-></i>

<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
    <c- n>I</c-> <c- n>uninitialized_fill_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->        <i><c- c1>// freestanding</c-></i>
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
    <c- n>I</c-> <c- n>uninitialized_fill</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->                <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>uninitialized_fill</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->     <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;></c->
    <c- n>I</c-> <c- n>uninitialized_fill_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c-> <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
</pre>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- k>constexpr</c-> <c- n>I</c-> <c- n>destroy</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->                              <i><c- c1>// freestanding</c-></i>
<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
    <c- k>constexpr</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>destroy</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->                   <i><c- c1>// freestanding</c-></i>

<c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
  <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- k>constexpr</c-> <c- n>I</c-> <c- n>destroy_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->            <i><c- c1>// freestanding</c-></i>
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
  <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>I</c-> <c- n>destroy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>S</c-> <c- n>last</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->                           <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- n>R</c-><c- o>></c->
  <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- n>sized_range</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
    <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- n>destroy</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>R</c-><c- o>&amp;&amp;</c-> <c- n>r</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->                <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>

<c- k>template</c-><c- o>&lt;</c-><c- n>execution</c-><c- o>-</c-><c- n>policy</c-> <c- n>ExecutionPolicy</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
  <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
    <c- n>I</c-> <c- n>destroy_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-> <c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->         <i><c- c1>// see [algorithms.parallel.overloads]</c-></i>
</pre>
   </ins>
   <h3 class="heading settled" data-level="8.50" id="modify_special_mem_concepts"><span class="secno">8.50. </span><span class="content">Add exposition only concepts to <a href="https://eel.is/c++draft/special.mem.concepts">[<strong>special.mem.concepts</strong>]</a></span><a class="self-link" href="#modify_special_mem_concepts"></a></h3>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>I</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i> <c- o>=</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>S</c-><c- p>,</c-> <c- n>I</c-><c- o>></c-><c- p>;</c-> <i><c- c1>// exposition only</c-></i>
</pre>
   <p>Types <code class="highlight"><c- n>S</c-></code> and <code class="highlight"><c- n>I</c-></code> model <code class="highlight"><i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i></code> only if no exceptions are thrown from copy construction,
move construction, copy assignment, move assignment, or comparisons between valid values of type <code class="highlight"><c- n>I</c-></code> and <code class="highlight"><c- n>S</c-></code>.</p>
   <p>[<em>Note X</em>: This concept allows some <code class="highlight"><c- n>sentinel_for</c-></code> ([iterator.concept.sentinel]) operations to throw exceptions. — <em>end note</em>]</p>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>S</c-><c- p>,</c-> <c- k>class</c-> <c- nc>I</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>S</c-><c- p>,</c-> <c- n>I</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <c- n>sized_sentinel_for</c-><c- o>&lt;</c-><c- n>S</c-><c- p>,</c-> <c- n>I</c-><c- o>></c-><c- p>;</c-> 
</pre>
    <p>Types <code class="highlight"><c- n>S</c-></code> and <code class="highlight"><c- n>I</c-></code> model <code class="highlight"><i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i></code> only if no exceptions are thrown from the <code class="highlight"><c- o>-</c-></code> operator
for valid values of type <code class="highlight"><c- n>I</c-></code> and <code class="highlight"><c- n>S</c-></code>.</p>
    <p>[<em>Note X</em>: This concept allows some <code class="highlight"><c- n>sized_sentinel_for</c-></code> ([iterator.concept.sizedsentinel]) operations to throw exceptions. — <em>end note</em>]</p>
   </ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>iterator</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <c- n>forward_iterator</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>I</c-><c- o>></c-><c- p>;</c->
</pre>
   <p>[<em>Note X</em>: This concept allows some <code class="highlight"><c- n>forward_iterator</c-></code> ([iterator.concept.forward]) operations to throw exceptions. — <em>end note</em>]</p>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>range</c-></i><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->
</pre>
   <ins>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <c- n>bidirectional_iterator</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-><c- p>;</c->
</pre>
    <p>A type <code class="highlight"><c- n>I</c-></code> models <code class="highlight"><i><c- n>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>iterator</c-></i></code> only if no exceptions are thrown from decrementing valid iterators.</p>
    <p>[<em>Note X</em>: This concept allows some <code class="highlight"><c- n>bidirectional_iterator</c-></code> ([iterator.concept.bidir]) operations to throw exceptions. — <em>end note</em>]</p>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>iterator</c-></i><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->
</pre>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>iterator</c-></i><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <c- n>random_access_iterator</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>sized</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>I</c-><c- o>></c-><c- p>;</c->
</pre>
    <p>A type <code class="highlight"><c- n>I</c-></code> models <code class="highlight"><i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i></code> only if no exceptions are thrown from advancement
with <code class="highlight"><c- o>+=</c-></code>, <code class="highlight"><c- o>+</c-></code>, <code class="highlight"><c- o>-=</c-></code>, and <code class="highlight"><c- o>-</c-></code>, comparisons, or applying the <code class="highlight"><c- p>[]</c-></code> subscript operator to valid iterators.</p>
    <p>[<em>Note X</em>: This concept allows some <code class="highlight"><c- n>random_access_iterator</c-></code> ([iterator.concept.random.access]) operations to throw exceptions. — <em>end note</em>]</p>
<pre class="wordingStyle highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- o>></c->
<c- k>concept</c-> <i><c- nc>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>range</c-></i> <c- o>=</c-> <i><c- c1>// exposition only</c-></i>
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>bidirectional</c-><c- o>-</c-><c- n>range</c-></i><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <i><c- n>nothrow</c-><c- o>-</c-><c- n>random</c-><c- o>-</c-><c- n>access</c-><c- o>-</c-><c- n>iterator</c-></i><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->
</pre>
   </ins>
   <h2 class="heading settled" data-level="9" id="revision_history"><span class="secno">9. </span><span class="content">Revision history</span><a class="self-link" href="#revision_history"></a></h2>
   <h3 class="heading settled" data-level="9.1" id="r3_r4"><span class="secno">9.1. </span><span class="content">R3 => R4</span><a class="self-link" href="#r3_r4"></a></h3>
   <ul>
    <li data-md>
     <p>Revert back to range-as-the-output design aspect, change the formal wording accordingly</p>
    <li data-md>
     <p>Revert back to requiring all ranges to be sized (<code class="highlight"><c- o>&amp;&amp;</c-></code> instead of <code class="highlight"><c- o>||</c-></code>)</p>
    <li data-md>
     <p>Clarify which execution policies are supported</p>
    <li data-md>
     <p>Clarify that new APIs extend algorithm function objects in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code></p>
    <li data-md>
     <p>Add the feature test macro</p>
    <li data-md>
     <p>Add implementation experience and thoughts on implementability</p>
    <li data-md>
     <p>Fix known bugs in the signatures wording</p>
    <li data-md>
     <p>Address other feedback from SG1 and SG9 and fix known bugs (see <a href="#issues_to_address">§ 7.1 Issues to address</a>):</p>
     <ul>
      <li data-md>
       <p>Decide on constraining the execution policy template parameter</p>
      <li data-md>
       <p>List all the algorithms that are being given execution policy overloads</p>
      <li data-md>
       <p>List range algorithms that are being excluded</p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="9.2" id="r2_r3"><span class="secno">9.2. </span><span class="content">R2 => R3</span><a class="self-link" href="#r2_r3"></a></h3>
   <ul>
    <li data-md>
     <p>Use <code class="highlight"><c- n>iterator</c-></code> as an output</p>
    <li data-md>
     <p>Add wording</p>
   </ul>
   <h3 class="heading settled" data-level="9.3" id="r1_r2"><span class="secno">9.3. </span><span class="content">R1 => R2</span><a class="self-link" href="#r1_r2"></a></h3>
   <ul>
    <li data-md>
     <p>Summarize proposed differences from the serial range algorithms and from the non-range parallel algorithms</p>
    <li data-md>
     <p>Allow all but one input sequences to be unbounded</p>
    <li data-md>
     <p>List existing algorithms that take ranges for output</p>
    <li data-md>
     <p>Update arguments and mitigation for using ranges for output</p>
    <li data-md>
     <p>Add more arguments in support of random access ranges</p>
    <li data-md>
     <p>Fix the signatures of <code class="highlight"><c- n>for_each</c-></code> to match the proposed design</p>
   </ul>
   <h3 class="heading settled" data-level="9.4" id="r0_r1"><span class="secno">9.4. </span><span class="content">R0 => R1</span><a class="self-link" href="#r0_r1"></a></h3>
   <ul>
    <li data-md>
     <p>Address the feedback from SG1 and SG9 review</p>
    <li data-md>
     <p>Add more information about iterator constraints</p>
    <li data-md>
     <p>Propose <code class="highlight"><c- n>range</c-></code> as an output for the algorithms</p>
    <li data-md>
     <p>Require ranges to be bounded</p>
   </ul>
   <h2 class="heading settled" data-level="10" id="polls"><span class="secno">10. </span><span class="content">Polls</span><a class="self-link" href="#polls"></a></h2>
   <h3 class="heading settled" data-level="10.1" id="sg9_wroclaw_2024"><span class="secno">10.1. </span><span class="content">SG9, Wroclaw, 2024</span><a class="self-link" href="#sg9_wroclaw_2024"></a></h3>
   <p><strong>Poll 1</strong>: Change <code class="highlight"><c- n>mismatch</c-></code> and <code class="highlight"><c- n>equal</c-></code> to require <code class="highlight"><c- n>sized_range</c-></code> for both inputs ("<code class="highlight"><c- o>&amp;&amp;</c-></code> instead of <code class="highlight"><c- o>||</c-></code>").</p>
   <table>
    <tbody>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
     <tr>
      <td>4
      <td>3
      <td>1
      <td>0
      <td>0
   </table>
   <p><strong>Poll 2</strong>: Change <code class="highlight"><c- n>transform</c-></code> to require <code class="highlight"><c- n>sized_range</c-></code> for both inputs ("<code class="highlight"><c- o>&amp;&amp;</c-></code> instead of <code class="highlight"><c- o>||</c-></code>"),
with the plan to relax these constraints once we have a way to statically detect infinite ranges.</p>
   <table>
    <tbody>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
     <tr>
      <td>3
      <td>3
      <td>0
      <td>1
      <td>1
   </table>
   <p><strong>Poll 3</strong>: We want to remove the "legacy" overload that includes only an iterator as output for convenience, because we know it’s unsafe.</p>
   <table>
    <tbody>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
     <tr>
      <td>4
      <td>4
      <td>0
      <td>0
      <td>0
   </table>
   <p><strong>Poll 4</strong> Forward P3179R3 with the changes in P3490R0 (as updated above) to LEWG for inclusion in C++26 with these changes polled above.</p>
   <table>
    <tbody>
     <tr>
      <th>SF 
      <th>F 
      <th>N 
      <th>A 
      <th>SA 
     <tr>
      <td>4 
      <td>5 
      <td>0 
      <td>0 
      <td>0 
   </table>
   <h3 class="heading settled" data-level="10.2" id="sg1_wroclaw_2024"><span class="secno">10.2. </span><span class="content">SG1, Wroclaw, 2024</span><a class="self-link" href="#sg1_wroclaw_2024"></a></h3>
   <p>Forward P3179R3 to LEWG with the following notes:</p>
   <ol>
    <li data-md>
     <p>The intention is that algorithms call <code class="highlight"><c- n>begin</c-></code>/<code class="highlight"><c- n>end</c-></code> only once, in serial code
 (we do not think any new words are needed)</p>
    <li data-md>
     <p>The intention is that <code class="highlight"><c- n>mismatch</c-></code>, <code class="highlight"><c- n>transform</c-></code> and <code class="highlight"><c- n>equal</c-></code> assume the unsized range
 is at least as large as the sized one (UB / precondition) or require &amp;&amp; sized</p>
   </ol>
   <table>
    <tbody>
     <tr>
      <th>SF 
      <th>F 
      <th>N 
      <th>A 
      <th>SA 
     <tr>
      <td>4 
      <td>8 
      <td>0 
      <td>0 
      <td>0 
   </table>
   <h3 class="heading settled" data-level="10.3" id="sg1_sg9_st_louis_2024"><span class="secno">10.3. </span><span class="content">Joint SG1 + SG9, St. Louis, 2024</span><a class="self-link" href="#sg1_sg9_st_louis_2024"></a></h3>
   <p><strong>Poll</strong>: Continue work on P3179R2 for IS’26 with these notes:</p>
   <ol>
    <li data-md>
     <p>RandomAccess for inputs and outputs</p>
    <li data-md>
     <p>Iterators for outputs</p>
    <li data-md>
     <p>We believe the overloads are worth it</p>
   </ol>
   <table>
    <tbody>
     <tr>
      <th>SF 
      <th>F 
      <th>N 
      <th>A 
      <th>SA 
     <tr>
      <td>7 
      <td>4 
      <td>2 
      <td>1 
      <td>0 
   </table>
   <h3 class="heading settled" data-level="10.4" id="sg9_tokyo_2024"><span class="secno">10.4. </span><span class="content">SG9, Tokyo, 2024</span><a class="self-link" href="#sg9_tokyo_2024"></a></h3>
   <p><strong>Poll 1</strong>: <code class="highlight"><c- n>for_each</c-></code> shouldn’t return the callable</p>
   <table>
    <tbody>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
     <tr>
      <td>2
      <td>4
      <td>2
      <td>0
      <td>0
   </table>
   <p><strong>Poll 2</strong>: Parallel <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> algos should return the same type as serial <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-></code> algos</p>
   <table>
    <tbody>
     <tr>
      <td>Unanimous consent.
   </table>
   <p><strong>Poll 3</strong>: Parallel ranges algos should require <code class="highlight"><c- n>forward_range</c-></code>, not <code class="highlight"><c- n>random_access_range</c-></code></p>
   <table>
    <tbody>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
     <tr>
      <td>3
      <td>2
      <td>3
      <td>1
      <td>1
   </table>
   <p><strong>Poll 4</strong>: Range-based parallel algos should require const operator()</p>
   <table>
    <tbody>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
     <tr>
      <td>0
      <td>7
      <td>2
      <td>0
      <td>0
   </table>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don't scroll to compensate for the ToC if we're above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don't know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn't exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn't standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don't have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we're at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can't find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-p1068r11">[P1068R11]
   <dd>Ilya Burylov, Pavel Dyakov, Ruslan Arutyunyan, Andrey Nikolaev, Alina Elizarova. <a href="https://wg21.link/p1068r11"><cite>Vector API for random number generation</cite></a>. 2 April 2024. URL: <a href="https://wg21.link/p1068r11">https://wg21.link/p1068r11</a>
   <dt id="biblio-p2300r9">[P2300R9]
   <dd>Eric Niebler, Michał Dominiak, Georgy Evtushenko, Lewis Baker, Lucian Radu Teodorescu, Lee Howes, Kirk Shoop, Michael Garland, Bryce Adelstein Lelbach. <a href="https://wg21.link/p2300r9"><cite>`std::execution`</cite></a>. 2 April 2024. URL: <a href="https://wg21.link/p2300r9">https://wg21.link/p2300r9</a>
   <dt id="biblio-p2408r5">[P2408R5]
   <dd>David Olsen. <a href="https://wg21.link/p2408r5"><cite>Ranges iterators as inputs to non-Ranges algorithms</cite></a>. 22 April 2022. URL: <a href="https://wg21.link/p2408r5">https://wg21.link/p2408r5</a>
   <dt id="biblio-p2500r2">[P2500R2]
   <dd>Ruslan Arutyunyan, Alexey Kukanov. <a href="https://wg21.link/p2500r2"><cite>C++ parallel algorithms and P2300</cite></a>. 15 October 2023. URL: <a href="https://wg21.link/p2500r2">https://wg21.link/p2500r2</a>
   <dt id="biblio-p2902r0">[P2902R0]
   <dd>Oliver Rosten. <a href="https://wg21.link/p2902r0"><cite>constexpr 'Parallel' Algorithms</cite></a>. 17 June 2023. URL: <a href="https://wg21.link/p2902r0">https://wg21.link/p2902r0</a>
   <dt id="biblio-p3136r0">[P3136R0]
   <dd>Tim Song. <a href="https://wg21.link/p3136r0"><cite>Retiring niebloids</cite></a>. 15 February 2024. URL: <a href="https://wg21.link/p3136r0">https://wg21.link/p3136r0</a>
   <dt id="biblio-p3159r0">[P3159R0]
   <dd>Bryce Adelstein Lelbach. <a href="https://wg21.link/p3159r0"><cite>C++ Range Adaptors and Parallel Algorithms</cite></a>. 18 March 2024. URL: <a href="https://wg21.link/p3159r0">https://wg21.link/p3159r0</a>
   <dt id="biblio-p3179r0">[P3179R0]
   <dd>Ruslan Arutyunyan, Alexey Kukanov. <a href="https://wg21.link/p3179r0"><cite>C++ parallel range algorithms</cite></a>. 15 March 2024. URL: <a href="https://wg21.link/p3179r0">https://wg21.link/p3179r0</a>
   <dt id="biblio-p3179r2">[P3179R2]
   <dd>Ruslan Arutyunyan, Alexey Kukanov, Bryce Adelstein Lelbach. <a href="https://wg21.link/p3179r2"><cite>C++ parallel range algorithms</cite></a>. 25 June 2024. URL: <a href="https://wg21.link/p3179r2">https://wg21.link/p3179r2</a>
   <dt id="biblio-p3300r0">[P3300R0]
   <dd>Bryce Adelstein Lelbach. <a href="https://wg21.link/p3300r0"><cite>C++ Asynchronous Parallel Algorithms</cite></a>. 15 February 2024. URL: <a href="https://wg21.link/p3300r0">https://wg21.link/p3300r0</a>
   <dt id="biblio-p3490r0">[P3490R0]
   <dd>Alexey Kukanov; Ruslan Arutyunyan. <a href="http://www.wg21.link/P3490R0"><cite>Justification for range-as-an-output for parallel range algorithms</cite></a>. URL: <a href="http://www.wg21.link/P3490R0">http://www.wg21.link/P3490R0</a>
  </dl>