<!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>P2363R3: Extending associative containers with the remaining heterogeneous overloads</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;
		}
		#toc .content:hover,
		#toc .content:focus {
			background: rgba(75%, 75%, 75%, .25);
			background: var(--a-hover-bg);
			border-bottom: 3px solid #054572;
			border-bottom: 3px solid var(--toclink-underline);
			margin-bottom: -3px;
		}
		#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 span:not(.dfn-paneled) {
			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 type="text/css">
    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 bbc364800, updated Mon Nov 15 13:57:55 2021 -0800" name="generator">
  <link href="http://wg21.link/P2363R3" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="ec1ccfa8e0a32d243dab2878220660082b966154" name="document-revision">
<style>
img.resize {
  max-width:75%;
  max-height:75%;
}
ins {
  text-decoration: none;
}
</style>
<style>/* 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;
}</style>
<style>/* 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;
}</style>
<style>/* 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>/* style-issues */

a[href].issue-return {
    float: right;
    float: inline-end;
    color: var(--issueheading-text);
    font-weight: bold;
    text-decoration: none;
}
</style>
<style>/* 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>/* 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%;
}
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>/* 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 */
</style>
<style>/* style-darkmode */

@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; }
}
@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}

@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">P2363R3<br>Extending associative containers with the remaining heterogeneous overloads</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="2022-01-19">2022-01-19</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="http://wg21.link/P2363R3">http://wg21.link/P2363R3</a>
     <dt class="editor">Authors:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:konstantin.boyarinov@intel.com">Konstantin Boyarinov</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:sergey.vinogradov@intel.com">Sergey Vinogradov</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:ruslan.arutyunyan@intel.com">Ruslan Arutyunyan</a> (<span class="p-org org">Intel</span>)
     <dt>Audience:
     <dd>LEWG
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
    </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>The authors propose heterogeneous overloads for the remaining member functions in ordered and unordered associative

          containers.</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="#intro"><span class="secno">1</span> <span class="content">Motivation</span></a>
    <li><a href="#prior"><span class="secno">2</span> <span class="content">Prior work</span></a>
    <li>
     <a href="#over"><span class="secno">3</span> <span class="content">Proposal overview</span></a>
     <ol class="toc">
      <li><a href="#tr_empl"><span class="secno">3.1</span> <span class="content"><code class="highlight"><c- n>try_emplace</c-></code></span></a>
      <li><a href="#ins_assign"><span class="secno">3.2</span> <span class="content"><code class="highlight"><c- n>insert_or_assign</c-></code></span></a>
      <li><a href="#subscript"><span class="secno">3.3</span> <span class="content"><code class="highlight"><c- k>operator</c-><c- p>[]</c-></code></span></a>
      <li><a href="#at"><span class="secno">3.4</span> <span class="content"><code class="highlight"><c- n>at</c-></code></span></a>
      <li><a href="#bucket"><span class="secno">3.5</span> <span class="content"><code class="highlight"><c- n>bucket</c-></code></span></a>
      <li><a href="#ins"><span class="secno">3.6</span> <span class="content"><code class="highlight"><c- n>insert</c-></code></span></a>
      <li>
       <a href="#decisions"><span class="secno">3.7</span> <span class="content">Design decisions</span></a>
       <ol class="toc">
        <li><a href="#dec_constraints"><span class="secno">3.7.1</span> <span class="content">Constructibility constraints</span></a>
        <li><a href="#dec_implicit"><span class="secno">3.7.2</span> <span class="content">Insertion of implicitly convertible types</span></a>
        <li>
         <a href="#dec_conv_comp_consistency"><span class="secno">3.7.3</span> <span class="content">Conversion and comparison consistency</span></a>
         <ol class="toc">
          <li><a href="#dec_inconsitency_today"><span class="secno">3.7.3.1</span> <span class="content">Inconsistency of comparison and conversion today</span></a>
         </ol>
        <li><a href="#dec_multiple_match"><span class="secno">3.7.4</span> <span class="content">Use-cases with multiple matches</span></a>
        <li><a href="#dec_at"><span class="secno">3.7.5</span> <span class="content"><code class="highlight"><c- n>at</c-></code> method design rationale</span></a>
       </ol>
      <li><a href="#summary"><span class="secno">3.8</span> <span class="content">Proposed API summary</span></a>
      <li><a href="#perf"><span class="secno">3.9</span> <span class="content">Performance evaluation</span></a>
     </ol>
    <li>
     <a href="#word"><span class="secno">4</span> <span class="content">Formal wording</span></a>
     <ol class="toc">
      <li><a href="#word_map_syn"><span class="secno">4.1</span> <span class="content">Modify class template <kbd>map</kbd> synopsis <span>[<strong>map.overview</strong>] </span></span></a>
      <li><a href="#word_map_access"><span class="secno">4.2</span> <span class="content">Modify <span>[<strong>map.access</strong>]</span></span></a>
      <li><a href="#word_map_mod"><span class="secno">4.3</span> <span class="content">Modify <span>[<strong>map.modifiers</strong>]</span></span></a>
      <li><a href="#word_set_syn"><span class="secno">4.4</span> <span class="content">Modify class template <kbd>set</kbd> synopsis <span>[<strong>set.overview</strong>]</span></span></a>
      <li><a href="#word_set_mod"><span class="secno">4.5</span> <span class="content">Add paragraph <b>Modifiers</b> into <span>[<strong>set.overview</strong>]</span></span></a>
      <li><a href="#word_tab_hash"><span class="secno">4.6</span> <span class="content">Modify <span>[<strong>tab.container.hash.req</strong>]</span></span></a>
      <li><a href="#word_req_hash"><span class="secno">4.7</span> <span class="content">Modify paragraph � in <span>[<strong>unord.req.general</strong>]</span></span></a>
      <li><a href="#word_unord_map_syn"><span class="secno">4.8</span> <span class="content">Modify class template <kbd>unordered_map</kbd> synopsis <span>[<strong>unord.map.overview</strong>]</span></span></a>
      <li><a href="#word_unord_map_access"><span class="secno">4.9</span> <span class="content">Modify <span>[<strong>unord.map.access</strong>]</span></span></a>
      <li><a href="#word_unord_map_mod"><span class="secno">4.10</span> <span class="content">Modify <span>[<strong>unord.map.modifiers</strong>]</span></span></a>
      <li><a href="#word_unord_multimap_syn"><span class="secno">4.11</span> <span class="content">Modify class template <kbd>unordered_multimap</kbd> synopsis <span>[<strong>unord.multimap.overview</strong>]</span></span></a>
      <li><a href="#word_unord_set_syn"><span class="secno">4.12</span> <span class="content">Modify class template <kbd>unordered_set</kbd> synopsis <span>[<strong>unord.set.overview</strong>]</span></span></a>
      <li><a href="#word_unord_set_mod"><span class="secno">4.13</span> <span class="content">Add paragraph <b>Modifiers</b> into <span>[<strong>unord.set.overview</strong>]</span></span></a>
      <li><a href="#word_unord_multiset_syn"><span class="secno">4.14</span> <span class="content">Modify class template <kbd>unordered_multiset</kbd> synopsis <span>[<strong>unord.multiset.overview</strong>]</span></span></a>
     </ol>
    <li>
     <a href="#history"><span class="secno">5</span> <span class="content">Revision history</span></a>
     <ol class="toc">
      <li><a href="#r2#r3"><span class="secno">5.1</span> <span class="content">R2 ➡ R3</span></a>
      <li><a href="#r1#r2"><span class="secno">5.2</span> <span class="content">R1 ➡ R2</span></a>
      <li><a href="#r0r1"><span class="secno">5.3</span> <span class="content">R0 ➡ R1</span></a>
     </ol>
    <li><a href="#acknow"><span class="secno">6</span> <span class="content">Acknowledgments</span></a>
    <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="intro"><span class="secno">1. </span><span class="content">Motivation</span><a class="self-link" href="#intro"></a></h2>
   <p><a data-link-type="biblio" href="#biblio-n3657">[N3657]</a> and <a data-link-type="biblio" href="#biblio-p0919r0">[P0919R0]</a> introduced heterogeneous lookup support for ordered and unordered
associative containers in C++ Standard Library. <a data-link-type="biblio" href="#biblio-p2077r2">[P2077R2]</a> proposed heterogeneous erasure overloads.
As a result, a temporary key object is not created when a different (but comparable) type is provided as a key to the member function.
But there are still no heterogeneous overloads for methods such as <code class="highlight"><c- n>insert_or_assign</c-></code>, <code class="highlight"><c- k>operator</c-><c- p>[]</c-></code> and others.</p>
   <p>Consider the following example:</p>
<pre class="language-cpp highlight"><c- b>void</c-> <c- nf>foo</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>map</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- p>,</c-> <c- b>int</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>less</c-><c- o>&lt;</c-><c- b>void</c-><c- o>>>&amp;</c-> <c- n>m</c-><c- p>)</c-> <c- p>{</c->
    <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>lookup_str</c-> <c- o>=</c-> <c- s>"Lookup_str"</c-><c- p>;</c->
    <c- k>auto</c-> <c- n>it</c-> <c- o>=</c-> <c- n>m</c-><c- p>.</c-><c- n>find</c-><c- p>(</c-><c- n>lookup_str</c-><c- p>);</c-> <c- c1>// matches to template overload</c->
    <c- c1>// ...</c->
    <c- k>auto</c-> <c- n>result</c-> <c- o>=</c-> <c- n>m</c-><c- p>.</c-><c- n>insert_or_assign</c-><c- p>(</c-><c- n>lookup_str</c-><c- p>,</c-> <c- mi>1</c-><c- p>);</c-> <c- c1>// no heterogeneous alternative</c->
<c- p>}</c->
</pre>
   <p>Function <code class="highlight"><c- n>foo</c-></code> accepts a reference to the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- p>,</c-> <c- b>int</c-><c- o>></c-></code> object. A
comparator for the map is <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>less</c-><c- o>&lt;</c-><c- b>void</c-><c- o>></c-></code>, which provides <code class="highlight"><c- n>is_transparent</c-></code> valid
qualified-id, so the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> allows using heterogeneous overloads with <code class="highlight"><c- n>Key</c-></code> template
parameter for lookup functions, such as <code class="highlight"><c- n>find</c-></code>, <code class="highlight"><c- n>upped_bound</c-></code>, <code class="highlight"><c- n>equal_range</c-></code>, etc.</p>
   <p>In the example above, the <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>find</c-><c- p>(</c-><c- n>lookup_str</c-><c- p>)</c-></code> call does not create a temporary object of
the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> to perform a lookup. But the <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>insert_or_assign</c-><c- p>(</c-><c- n>lookup_str</c-><c- p>,</c-> <c- mi>1</c-><c- p>)</c-></code> call causes implicit
conversion from <code class="highlight"><c- k>const</c-> <c- b>char</c-><c- o>*</c-></code> to <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> even if the insertion will not take place.
The allocation and construction (as well as subsequent destruction and deallocation) of the temporary object of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> <i>or any custom object</i> might be quite expensive and reduce the program performance.</p>
   <p>All the proposed APIs in this paper allow to avoid mentioned performance penalty.</p>
   <h2 class="heading settled" data-level="2" id="prior"><span class="secno">2. </span><span class="content">Prior work</span><a class="self-link" href="#prior"></a></h2>
   <p>Heterogeneous lookup overloads for ordered and unordered associative containers were added into C++ standard. For example:</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>iterator</c-> <c- n>find</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p>The corresponding overloads were added for <code class="highlight"><c- n>count</c-></code>, <code class="highlight"><c- n>contains</c-></code>, <code class="highlight"><c- n>equal_range</c-></code>, <code class="highlight"><c- n>lower_bound</c-></code> and <code class="highlight"><c- n>upper_bound</c-></code> member functions.</p>
   <p><a data-link-type="biblio" href="#biblio-p2077r2">[P2077R2]</a> proposed heterogeneous erasure overloads for ordered and unordered associative containers:</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>size_type</c-> <c- n>erase</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->

<c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>node_type</c-> <c- n>extract</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p>Constraints:</p>
   <ul>
    <li data-md>
     <p>qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type for ordered associative containers</p>
    <li data-md>
     <p>qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types for unordered associative containers</p>
   </ul>
   <p>where <code class="highlight"><c- n>Compare</c-></code> is a type of comparator passed to an ordered container, <code class="highlight"><c- n>Hash</c-></code> and <code class="highlight"><c- n>Pred</c-></code> are types of hash function and key equality
predicate passed to an unordered container respectively.</p>
   <h2 class="heading settled" data-level="3" id="over"><span class="secno">3. </span><span class="content">Proposal overview</span><a class="self-link" href="#over"></a></h2>
   <p>We propose to add heterogeneous overloads for the following member functions:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>insert</c-></code> in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_set</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>insert_or_assign</c-></code>, <code class="highlight"><c- n>try_emplace</c-></code>, <code class="highlight"><c- k>operator</c-><c- p>[]</c-></code>, <code class="highlight"><c- n>at</c-></code> in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code></p>
    <li data-md>
     <p><code class="highlight"><c- n>bucket</c-></code> in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_set</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_multiset</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_multimap</c-></code></p>
   </ul>
   <h3 class="heading settled" data-level="3.1" id="tr_empl"><span class="secno">3.1. </span><span class="content"><code class="highlight"><c- n>try_emplace</c-></code></span><a class="self-link" href="#tr_empl"></a></h3>
   <p>We propose the following API (<code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>):</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- p>,</c-> <c- k>typename</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
<c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

<c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- p>,</c-> <c- k>typename</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
<c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
</pre>
   <p>Effects: If the map already contains an element whose key compares equivalent with <code class="highlight"><c- n>k</c-></code>, there is no effect. Otherwise,
inserts an object of type <code class="highlight"><c- n>value_type</c-></code> constructed with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>piecewise_construct</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>forward_as_tuple</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)),</c-> <c- n>std</c-><c- o>::</c-><c- n>forward_as_tuple</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...)</c-></code>.</p>
   <p>Constraints:</p>
   <ol>
    <li data-md>
     <p>For ordered associative containers: qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type
For unordered associative containers: qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types</p>
    <li data-md>
     <p><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>const_iterator</c-><c- o>></c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>iterator</c-><c- o>></c-></code> are both <code class="highlight">false</code>.</p>
   </ol>
   <p>Constraint 2 is introduced to maintain backward compatibility and makes homogeneous overload to be called when <code class="highlight"><c- n>K</c-><c- o>&amp;&amp;</c-></code> is convertible to <code class="highlight"><c- n>const_iterator</c-></code> or to <code class="highlight"><c- n>iterator</c-></code>.</p>
   <h3 class="heading settled" data-level="3.2" id="ins_assign"><span class="secno">3.2. </span><span class="content"><code class="highlight"><c- n>insert_or_assign</c-></code></span><a class="self-link" href="#ins_assign"></a></h3>
   <p>We propose the following API (<code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>):</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- p>,</c-> <c- k>typename</c-> <c- nc>M</c-><c- o>></c->
<c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- p>,</c-> <c- k>typename</c-> <c- nc>M</c-><c- o>></c->
<c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</pre>
   <p>Effects: If the map already contains an element <code class="highlight"><c- n>e</c-></code> whose key compares equivalent with <code class="highlight"><c- n>k</c-></code>, assigns <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></code> to <code class="highlight"><c- n>e</c-><c- p>.</c-><c- n>second</c-></code>.
Otherwise, inserts an object of type <code class="highlight"><c- n>value_type</c-></code> constructed with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></code>.</p>
   <p>Constraints:</p>
   <ul>
    <li data-md>
     <p>For ordered associative containers: qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type
  For unordered associative containers: qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types</p>
   </ul>
   <p>Backward compatibility problem in case of <code class="highlight"><c- n>K</c-><c- o>&amp;&amp;</c-></code> convertibility to <code class="highlight"><c- n>iterator</c-></code> or <code class="highlight"><c- n>const_iterator</c-></code> will not take place
because the number of arguments is fixed - call with three arguments would always consider the overloads with <code class="highlight"><c- n>hint</c-></code> only.</p>
   <h3 class="heading settled" data-level="3.3" id="subscript"><span class="secno">3.3. </span><span class="content"><code class="highlight"><c- k>operator</c-><c- p>[]</c-></code></span><a class="self-link" href="#subscript"></a></h3>
   <p>We propose the following API (<code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>):</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->
</pre>
   <p>Effects: Equivalent to: <code class="highlight"><c- k>return</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)).</c-><c- n>first</c-><c- o>-></c-><c- n>second</c-></code>.</p>
   <p>Constraints:</p>
   <ul>
    <li data-md>
     <p>For ordered associative containers: qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type
  For unordered associative containers: qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types</p>
   </ul>
   <h3 class="heading settled" data-level="3.4" id="at"><span class="secno">3.4. </span><span class="content"><code class="highlight"><c- n>at</c-></code></span><a class="self-link" href="#at"></a></h3>
   <p>We propose the following API (<code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>):</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>);</c->

<c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <p>Returns: A reference to the <code class="highlight"><c- n>mapped_type</c-></code> corresponding to <code class="highlight"><c- n>k</c-></code> in <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p>Throws: An exception object of type <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>out_of_range</c-></code> if no such element is present.</p>
   <p>Constraints:</p>
   <ul>
    <li data-md>
     <p>For ordered associative containers: qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type
  For unordered associative containers: qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types</p>
   </ul>
   <h3 class="heading settled" data-level="3.5" id="bucket"><span class="secno">3.5. </span><span class="content"><code class="highlight"><c- n>bucket</c-></code></span><a class="self-link" href="#bucket"></a></h3>
   <p>We propose the following API (<code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_multimap</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_set</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_multiset</c-></code>):</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>size_type</c-> <c- n>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <p>Returns: The index of the bucket in which elements with keys compared equivalent with <code class="highlight"><c- n>k</c-></code> would be found, if any such element
existed.</p>
   <p>Constraints:</p>
   <ul>
    <li data-md>
     <p>For ordered associative containers: qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type
  For unordered associative containers: qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types</p>
   </ul>
   <h3 class="heading settled" data-level="3.6" id="ins"><span class="secno">3.6. </span><span class="content"><code class="highlight"><c- n>insert</c-></code></span><a class="self-link" href="#ins"></a></h3>
   <p>We considered to add heterogeneous overloads of <code class="highlight"><c- n>insert</c-></code> for all associative containers, but found the applicability only for <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_set</c-></code> with the following API:</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->

<c- k>template</c-> <c- o>&lt;</c-><c- k>typename</c-> <c- nc>K</c-><c- o>></c->
<c- n>iterator</c-> <c- n>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->
</pre>
   <p>Effects: If the set already contains an element which compares equivalent with <code class="highlight"><c- n>k</c-></code>, there is no effect. Otherwise,
inserts an object constructed with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> into the set.</p>
   <p>Constraints:</p>
   <ul>
    <li data-md>
     <p>For ordered associative containers: qualified-id <code class="highlight"><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></code> is valid and denotes a type
  For unordered associative containers: qualified-ids <code class="highlight"><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></code> and <code class="highlight"><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></code> are valid and denote types</p>
   </ul>
   <p>Adding heterogeneous <code class="highlight"><c- n>insert</c-></code> overload makes no sence for associative containers with non-unique keys (<code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>multimap</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>multiset</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_multimap</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_multiset</c-></code>)
because the insertion will be successful in any case and the key would be always constracted. All additional overheads introduced by <code class="highlight"><c- n>insert</c-></code> can be mitigated by using <code class="highlight"><c- n>emplace</c-></code>.</p>
   <p>For <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unordered_map</c-></code>, heterogeneous insertion also makes no sence since
heterogeneous <code class="highlight"><c- n>try_emplace</c-></code> covers the relevant use cases.</p>
   <h3 class="heading settled" data-level="3.7" id="decisions"><span class="secno">3.7. </span><span class="content">Design decisions</span><a class="self-link" href="#decisions"></a></h3>
   <h4 class="heading settled" data-level="3.7.1" id="dec_constraints"><span class="secno">3.7.1. </span><span class="content">Constructibility constraints</span><a class="self-link" href="#dec_constraints"></a></h4>
   <p>We do not introduce the following constraint: <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_constructible_v</c-><c- o>&lt;</c-><c- n>value_type</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>Arguments</c-><c- o>></c-></code> for <code class="highlight"><c- n>try_emplace</c-></code>, <code class="highlight"><c- n>insert_or_assign</c-></code>, <code class="highlight"><c- k>operator</c-><c- p>[]</c-></code> and <code class="highlight"><c- n>insert</c-></code> member functions.</p>
   <p>The only use-case when the homogeneous overload of the corresponding member function should be selected is the case when <code class="highlight"><c- n>K</c-><c- o>&amp;&amp;</c-></code> is convertible to <code class="highlight"><c- n>key_type</c-></code>, but <code class="highlight"><c- n>key_type</c-></code> is not constructible from <code class="highlight"><c- n>K</c-><c- o>&amp;&amp;</c-></code>. We decided not to consider such a use case
as important to maintain.</p>
   <p>The condition <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_constructible_v</c-><c- o>&lt;</c-><c- n>value_type</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>Arguments</c-><c- o>></c-></code> is considered as a precondition for the corresponding member function.</p>
   <h4 class="heading settled" data-level="3.7.2" id="dec_implicit"><span class="secno">3.7.2. </span><span class="content">Insertion of implicitly convertible types</span><a class="self-link" href="#dec_implicit"></a></h4>
   <p>The proposed heterogeneous overloads for the insertion (such as <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>::</c-><c- n>insert</c-></code>) can result in adding heterogeneous keys
that are only explicitly convertible to <code class="highlight"><c- n>key_type</c-></code>.</p>
   <p>Consider the following example:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>owner_less</c-><c- o>&lt;>></c-> <c- n>s</c-><c- p>;</c->
<c- n>std</c-><c- o>::</c-><c- n>weak_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>w</c-> <c- o>=</c-> <c- d>/*...*/</c-><c- p>;</c->

<c- n>s</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>w</c-><c- p>);</c->
</pre>
   <p>The constructor of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-></code> from the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>weak_ptr</c-></code> is <code class="highlight"><c- k>explicit</c-></code>, so this code is currently ill-formed
and the user should choose how to get <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-></code> from <code class="highlight"><c- n>w</c-></code>.
If the heterogeneous overload for <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>::</c-><c- n>insert</c-></code> would be added, the code above would become well-formed because implicit
conversion is not required anymore and the insertion will happen via explicit conversion under the hood. If <code class="highlight"><c- n>w</c-></code> is expired, the insertion will
throw <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>bad_weak_ptr</c-></code>.</p>
   <p>We investigated adding constraints for heterogeneous overloads of the insertion methods so that they only participate in overload resolution if <code class="highlight"><c- n>K</c-><c- o>&amp;&amp;</c-></code> is both implicitly and explicitly convertible to <code class="highlight"><c- n>key_type</c-></code>, but it prohibits the use-case which is
useful and common from authors perspective:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- p>,</c-> <c- n>TransparentCharCompare</c-><c- o>></c-> <c- n>s</c-><c- p>;</c->
<c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>sv</c-> <c- o>=</c-> <c- d>/*...*/</c-><c- p>;</c->

<c- n>s</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>sv</c-><c- p>);</c->
</pre>
   <p>The constructor of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> from the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string_view</c-></code> is explicit, so if heterogeneous overloads would be constrained as
decribed above, the previous example would become ill-formed that forces the user to explicitly convert <code class="highlight"><c- n>sv</c-></code> to <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code>,
which adds overhead (see <a href="#perf">§ 3.9 Performance evaluation</a> for more details).</p>
   <p>Moreover, we found that the library already contains such precedences.
First, we can compare the behavior of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>::</c-><c- n>emplace</c-></code>:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>sptr</c-> <c- o>=</c-> <c- d>/*...*/</c-><c- p>;</c->
<c- n>std</c-><c- o>::</c-><c- n>weak_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>wptr</c-> <c- o>=</c-> <c- n>sptr</c-><c- p>;</c->

<c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>></c-> <c- n>v</c-><c- p>;</c->
<c- n>v</c-><c- p>.</c-><c- n>push_back</c-><c- p>(</c-><c- n>sptr</c-><c- p>);</c-> <c- c1>// OK</c->
<c- n>v</c-><c- p>.</c-><c- n>push_back</c-><c- p>(</c-><c- n>wptr</c-><c- p>);</c-> <c- c1>// Fail due to implicit conversion</c->
<c- n>v</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- n>wptr</c-><c- p>);</c-> <c- c1>// OK, insertion via explicit conversion</c->
</pre>
   <p>Another example is one of the overloads of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-><c- o>::</c-><c- n>insert</c-></code>:</p>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- k>class</c-> <c- nc>P</c-><c- o>></c->
<c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>P</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p>This overload is equivalent to <code class="highlight"><c- n>emplace</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>P</c-><c- o>></c-><c- p>(</c-><c- n>x</c-><c- p>))</c-></code>. Hence, <code class="highlight"><c- n>insert</c-><c- p>(</c-><c- n>value_type</c-><c- o>&amp;&amp;</c-><c- p>)</c-></code> and <code class="highlight"><c- n>insert</c-><c- p>(</c-><c- n>P</c-><c- o>&amp;&amp;</c-><c- p>)</c-></code> are overloads with different semantics and the availability of such an overload results in
the behavior described above. Consider:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>sptr</c-><c- p>;</c->
<c- n>std</c-><c- o>::</c-><c- n>weak_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>wptr</c-><c- p>;</c->

<c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>,</c-> <c- b>int</c-><c- o>></c-> <c- n>p1</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>make_pair</c-><c- p>(</c-><c- n>sptr</c-><c- p>,</c-> <c- mi>1</c-><c- p>);</c-> <c- c1>// OK</c->
<c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>,</c-> <c- b>int</c-><c- o>></c-> <c- n>p2</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>make_pair</c-><c- p>(</c-><c- n>wptr</c-><c- p>,</c-> <c- mi>1</c-><c- p>);</c-> <c- c1>// Fail</c->

<c- n>std</c-><c- o>::</c-><c- n>map</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>,</c-> <c- b>int</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>owner_less</c-><c- o>&lt;>></c-> <c- n>m</c-><c- p>;</c->
<c- n>m</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>make_pair</c-><c- p>(</c-><c- n>sptr</c-><c- p>,</c-> <c- mi>1</c-><c- p>));</c-> <c- c1>// OK</c->
<c- n>m</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>make_pair</c-><c- p>(</c-><c- n>wptr</c-><c- p>,</c-> <c- mi>1</c-><c- p>));</c-> <c- c1>// Also OK, equivalent to emplace</c->
</pre>
   <p>Based on the described scenarios we came to the following conclusions:</p>
   <ul>
    <li data-md>
     <p>Do not introduce additional constraints to allow heterogeneous instertion for such types like <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string_view</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> since
we believe it is more common and important use-case.</p>
    <li data-md>
     <p>The implicit insertion possiblity of explicitly convertible types(as for <code class="highlight"><c- n>weak_ptr</c-></code> and <code class="highlight"><c- n>shared_ptr</c-></code>) into
the containers already takes place in C++ standard library thus, doesn’t look like showstopper for this proposal.</p>
   </ul>
   <h4 class="heading settled" data-level="3.7.3" id="dec_conv_comp_consistency"><span class="secno">3.7.3. </span><span class="content">Conversion and comparison consistency</span><a class="self-link" href="#dec_conv_comp_consistency"></a></h4>
   <p>The conversion from the heterogeneous key to <code class="highlight"><c- n>key_type</c-></code> should be consistent with the heterogeneous lookup.</p>
   <p>Consider the following example where inconsistency leads to unexpected result:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>HeterogeneousKey</c-> <c- p>{</c->
  <c- b>int</c-> <c- n>value</c-><c- p>;</c->
  <c- k>operator</c-> <c- nf>int</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- o>-</c-><c- n>value</c-><c- p>;</c-> <c- p>}</c->
<c- p>};</c->

<c- k>struct</c-> <c- nc>Compare</c-> <c- p>{</c->
  <c- k>using</c-> <c- n>is_transparent</c-> <c- o>=</c-> <c- b>void</c-><c- p>;</c->

  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- b>int</c-> <c- n>lhs</c-><c- p>,</c-> <c- b>int</c-> <c- n>rhs</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>lhs</c-> <c- o>&lt;</c-> <c- n>rhs</c-><c- p>;</c->
  <c- p>}</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- b>int</c-> <c- n>lhs</c-><c- p>,</c-> <c- n>HeterogeneousKey</c-> <c- n>rhs</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>lhs</c-> <c- o>&lt;</c-> <c- n>rhs</c-><c- p>.</c-><c- n>value</c-><c- p>;</c->
  <c- p>}</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- n>HeterogeneousKey</c-> <c- n>lhs</c-><c- p>,</c-> <c- b>int</c-> <c- n>rhs</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>lhs</c-><c- p>.</c-><c- n>value</c-> <c- o>&lt;</c-> <c- n>rhs</c-><c- p>;</c->
  <c- p>}</c->
<c- p>};</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
  <c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- n>Compare</c-><c- o>></c-> <c- n>s</c-> <c- o>=</c-> <c- p>{</c-><c- mi>1</c-><c- p>,</c-> <c- mi>-2</c-><c- p>};</c->
  <c- n>s</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>HeterogeneousKey</c-><c- p>{</c-><c- mi>2</c-><c- p>});</c->
<c- p>}</c->
</pre>
   <p>In this case, <code class="highlight"><c- n>HeterogeneousKey</c-><c- p>{</c-><c- mi>2</c-><c- p>}</c-></code> will be compared with elements in the set as <code class="highlight"><c- mi>2</c-></code>, but would be inserted as <code class="highlight"><c- mi>-2</c-></code> and it results in broken <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-></code> structure due to equivalent elements in the container.</p>
   <p>Based on that, we need a precondition for heterogeneous insertion methods that the conversion from the heterogeneous key into <code class="highlight"><c- n>key_type</c-></code> should produce an object that can be found with the heterogeneous lookup with the same heterogeneous key.</p>
   <p>The example above also could result in breaking change. Currently the conversion from <code class="highlight"><c- n>HeterogeneousKey</c-></code> to <code class="highlight"><c- b>int</c-></code> is done before the insertion, so the value would be inserted only if the set does not contain elements that
homogeneously compares equivalent to the converted value. If the heterogeneous overload for <code class="highlight"><c- n>insert</c-></code> would be added,
the conversion would be done after the lookup phase inside the <code class="highlight"><c- n>insert</c-></code> and the value would be inserted only if the set
does not contain any elements that are heterogeneously compare equivalent to the <code class="highlight"><c- n>HeterogeneousKey</c-></code>.</p>
   <p>But we believe that the most common use-case for both heterogeneous lookup and insertion is the case when <code class="highlight"><c- n>key_type</c-></code> and
heterogeneous key represents the same thing like for <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string_view</c-></code>, which gives correct and
unambiguous conversion from the heterogeneous key to <code class="highlight"><c- n>key_type</c-></code>.</p>
   <h5 class="heading settled" data-level="3.7.3.1" id="dec_inconsitency_today"><span class="secno">3.7.3.1. </span><span class="content">Inconsistency of comparison and conversion today</span><a class="self-link" href="#dec_inconsitency_today"></a></h5>
   <p>We would like to highlight weird behavior when heterogeneous comparison and conversion are inconsistent
even without this proposal being accepted. Consider the following example:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>HalfIs</c-> <c- p>{</c->
  <c- b>int</c-> <c- n>value</c-><c- p>;</c->

  <c- k>operator</c-> <c- nf>int</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>value</c-> <c- o>*</c-> <c- mi>2</c-><c- p>;</c-> <c- p>}</c->
<c- p>};</c->

<c- k>struct</c-> <c- nc>Compare</c-> <c- p>{</c->
  <c- k>using</c-> <c- n>is_transparent</c-> <c- o>=</c-> <c- b>void</c-><c- p>;</c->

  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- b>int</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>y</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>x</c-> <c- o>&lt;</c-> <c- n>y</c-><c- p>;</c-> <c- p>}</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- b>int</c-> <c- n>x</c-><c- p>,</c-> <c- n>HalfIs</c-> <c- n>y</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>x</c-> <c- o>&lt;</c-> <c- n>y</c-> <c- o>/</c-> <c- mi>2</c-><c- p>;</c-> <c- p>}</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- n>HalfIs</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>y</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>x</c-> <c- o>/</c-> <c- mi>2</c-> <c- o>&lt;</c-> <c- n>y</c-><c- p>;</c-> <c- p>}</c->
<c- p>};</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
  <c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- n>Compare</c-><c- o>></c-> <c- n>s</c-> <c- o>=</c-> <c- p>{</c-><c- mi>1</c-><c- p>,</c-> <c- mi>2</c-><c- p>,</c-> <c- mi>3</c-><c- p>,</c-> <c- mi>5</c-><c- p>,</c-> <c- mi>6</c-><c- p>};</c->
  <c- k>if</c-> <c- p>(</c-><c- n>s</c-><c- p>.</c-><c- n>contains</c-><c- p>(</c-><c- n>HalfIs</c-><c- p>{</c-><c- mi>2</c-><c- p>}))</c-> <c- p>{</c->
    <c- b>bool</c-> <c- n>result</c-> <c- o>=</c-> <c- n>s</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>HalfIs</c-><c- p>{</c-><c- mi>2</c-><c- p>}).</c-><c- n>second</c-><c- p>;</c->
    <c- n>assert</c-><c- p>(</c-><c- n>result</c-> <c- o>==</c-> false<c- p>);</c-> <c- c1>// Fails</c->
    <c- n>assert</c-><c- p>(</c-><c- n>s</c-><c- p>.</c-><c- n>size</c-><c- p>()</c-> <c- o>==</c-> <c- mi>5</c-><c- p>);</c-> <c- c1>// Fails</c->
  <c- p>}</c->
<c- p>}</c->
</pre>
   <p>In the example above heterogeneous lookup could potentially find two values (because of dividing by 2 in heterogeneous comparator overload)
while <code class="highlight"><c- n>HalfIs</c-><c- o>::</c-><c- k>operator</c-> <c- b>int</c-></code> always produces the single value. <code class="highlight"><c- n>s</c-><c- p>.</c-><c- n>contains</c-><c- p>(</c-><c- n>HalfIs</c-><c- p>{</c-><c- mi>2</c-><c- p>})</c-></code> returns <code class="highlight">true</code> because the element <code class="highlight"><c- mi>5</c-></code> compares equivalent with the value <code class="highlight"><c- n>HalfIs</c-><c- p>{</c-><c- mi>2</c-><c- p>}</c-></code> but if
we try to add the same object into the container using <code class="highlight"><c- n>s</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>HalfIs</c-><c- p>{</c-><c- mi>2</c-><c- p>})</c-></code> - the insertion will be successful due to conversion <code class="highlight"><c- n>HalfIs</c-><c- p>{</c-><c- mi>2</c-><c- p>}</c-> <c- o>-></c-> <c- mi>4</c-></code>.</p>
   <p>We think that such a behavior is questionable - why are we able to insert the element into the set if it
already contains the equivalent one?</p>
   <h4 class="heading settled" data-level="3.7.4" id="dec_multiple_match"><span class="secno">3.7.4. </span><span class="content">Use-cases with multiple matches</span><a class="self-link" href="#dec_multiple_match"></a></h4>
   <p>The design of heterogeneous lookup and erasure allows the unique-key associative containers to hold unique elements in terms
of homogeneous comparisons, but potentially non-unique with heterogeneous comparisons:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>Employee</c-> <c- p>{</c->
  <c- c1>// First component of the pair is the lastname,</c->
  <c- c1>// the second is the firstname</c->
  <c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>></c-> <c- n>fullname</c-><c- p>;</c->

  <c- n>Employee</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>firstname</c-><c- p>,</c-> <c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>lastname</c-><c- p>)</c->
    <c- o>:</c-> <c- n>fullname</c-><c- p>(</c-><c- n>lastname</c-><c- p>,</c-> <c- n>firstname</c-><c- p>)</c-> <c- p>{}</c->

  <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>firstname</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>fullname</c-><c- p>.</c-><c- n>second</c-><c- p>;</c-> <c- p>}</c->
  <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>lastname</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>fullname</c-><c- p>.</c-><c- n>first</c-><c- p>;</c-> <c- p>}</c->
<c- p>};</c->

<c- k>struct</c-> <c- nc>Compare</c-> <c- p>{</c->
  <c- k>using</c-> <c- n>is_transparent</c-> <c- o>=</c-> <c- b>void</c-><c- p>;</c->

  <c- c1>// Homogeneous comparison - compares both firstname and lastname</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- k>const</c-> <c- n>Employee</c-><c- o>&amp;</c-> <c- n>lhs</c-><c- p>,</c-> <c- k>const</c-> <c- n>Employee</c-><c- o>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>lhs</c-><c- p>.</c-><c- n>fullname</c-> <c- o>&lt;</c-> <c- n>rhs</c-><c- p>.</c-><c- n>fullname</c-><c- p>;</c->
  <c- p>}</c->

  <c- c1>// Heterogeneous comparisons - compare lastname and Employees lastname</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- k>const</c-> <c- n>Employee</c-><c- o>&amp;</c-> <c- n>lhs</c-><c- p>,</c-> <c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>lhs</c-><c- p>.</c-><c- n>lastname</c-><c- p>()</c-> <c- o>&lt;</c-> <c- n>rhs</c-><c- p>;</c->
  <c- p>}</c->

  <c- c1>// Reversed heterogeneous comparison</c->
  <c- b>bool</c-> <c- nf>operator</c-><c- p>()(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>lhs</c-><c- p>,</c-> <c- k>const</c-> <c- n>Employee</c-><c- o>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>lhs</c-> <c- o>&lt;</c-> <c- n>rhs</c-><c- p>.</c-><c- n>lastname</c-><c- p>();</c->
  <c- p>}</c->
<c- p>};</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
  <c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>&lt;</c-><c- n>Employee</c-><c- p>,</c-> <c- n>Compare</c-><c- o>></c-> <c- n>s</c-> <c- o>=</c-> <c- p>{{</c-><c- s>"John"</c-><c- p>,</c-> <c- s>"Smith"</c-><c- p>},</c->
                                   <c- p>{</c-><c- s>"Oliver"</c-><c- p>,</c-> <c- s>"Twist"</c-><c- p>},</c->
                                   <c- p>{</c-><c- s>"William"</c-><c- p>,</c-> <c- s>"Smith"</c-><c- p>}};</c->

  <c- c1>// Below std::distance(r.first, r.second) == 2</c->
  <c- k>auto</c-> <c- n>r</c-> <c- o>=</c-> <c- n>s</c-><c- p>.</c-><c- n>equal_range</c-><c- p>(</c-><c- s>"Smith"</c-><c- p>);</c->
<c- p>}</c->
</pre>
   <p>This code creates a <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-></code> of employees that contains unique elements with homogeneous <code class="highlight"><c- n>Employee</c-><c- o>-</c-><c- n>Employee</c-></code> comparison - combinations of the firstname and the lastname are unique. But with heterogeneous <code class="highlight"><c- n>Employee</c-><c- o>-</c-><c- n>lastname</c-></code> comparison
the set may contain multiple matches of the employees with the same lastname. It allows the user to find
all Smiths in a set using single <code class="highlight"><c- n>equal_range</c-><c- p>(</c-><c- s>"Smith"</c-><c- p>)</c-></code> call. The returned range will contain both John Smith and William Smith.</p>
   <p>The reasonable question here is how should the heterogeneous insertion methods behave if multiple match occurred? In particular, <code class="highlight"><c- n>iterator</c-></code> to which element should be returned? Or how many elements should be modified by calling <code class="highlight"><c- n>insert_or_assign</c-></code>?</p>
   <p>In general case we cannot not imagine how to write consistent conversion operator with the heterogeneous comparator that produces
multiple match. If this scenario is possible then the answers could be that the returned iterator from the insertion should be defined
in a consistent way with heterogeneous <code class="highlight"><c- n>find</c-></code> where, in case of multiple matches, it returns the iterator to any mathed element.
Similarly, the <code class="highlight"><c- n>insert_or_assign</c-></code> assigns to any matched element.</p>
   <p>Below we provide the ruminations why constistent converstion operator for heterogeneous key in the use-case with multiple match for unique-key
containers is hardly possible.</p>
   <p>To use heterogeneous insertion for the example above, we need to define the conversion from <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> to <code class="highlight"><c- n>Employee</c-></code> to be able to emplace
the value into the set:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>Employee</c-> <c- p>{</c->
  <c- c1>// ...</c->
  <c- n>Employee</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>lname</c-><c- p>);</c->
  <c- c1>// ...</c->
<c- p>};</c->
</pre>
   <p>It’s unclear how this constructor with one string (e.g., representing last name) would restore both first and last names.
Thus, such construction does not seem meaningful. We think that for the use-case similar to above, such a conversion is
considered as an attepts to restore the element using one of its properties with no attention to other properties.
Similar examples are restoring the information about the car knowing that its color is red or restoring the integer
using its hashcode.</p>
   <p>One can argue that such a conversion can use a single string representing both first and last names, e.g. <code class="highlight"><c- s>"James Brown"</c-></code> and fill the fullname by parsing the string. But that leads to the problem described in <a href="#dec_multiple_match">§ 3.7.4 Use-cases with multiple matches</a> section.
Heterogeneous comparison should be written consistently to use the same parsing pattern, not just a single lastname
because otherwise, it (as it’s written in the example) would compare last name with the string representing the full name,
which leads to unpredictable results.</p>
   <p>To conclude. We believe that there are three possible scenarios on the user side:</p>
   <ul>
    <li data-md>
     <p>There is heterogeneous comparison that could result in multiple match and there is no converion from heterogeneous key to <code class="highlight"><c- n>key_type</c-></code>. In that case insertion (both homogeneous and heterogeneous) cannot be used and everything is just fine.</p>
    <li data-md>
     <p>There is heterogeneous comparison and a converion from heterogeneous key to <code class="highlight"><c- n>key_type</c-></code> that are consistent with
each other. In that case heterogeneous insertion produces the same effect on the container as homogeneous.
Everything works as user expects.</p>
    <li data-md>
     <p>There is heterogeneous comparison and a converion from heterogeneous key to <code class="highlight"><c- n>key_type</c-></code> that is <strong>not</strong> consistent with
heterogeneous comparison. This scenario is covered by <a href="#dec_conv_comp_consistency">§ 3.7.3 Conversion and comparison consistency</a> and <a href="#dec_multiple_match">§ 3.7.4 Use-cases with multiple matches</a> sections.
We suggest that it should be undefined behavior.</p>
   </ul>
   <h4 class="heading settled" data-level="3.7.5" id="dec_at"><span class="secno">3.7.5. </span><span class="content"><code class="highlight"><c- n>at</c-></code> method design rationale</span><a class="self-link" href="#dec_at"></a></h4>
   <p>Despite that <code class="highlight"><c- n>at</c-></code> method is put together with <code class="highlight"><c- k>operator</c-><c- p>[]</c-></code> to "Element access" section
in C++ standard, semantically it is much closer to <code class="highlight"><c- n>find</c-></code> method because it does not
make an insertion in case of element absence.
Thus, we would like to specify <code class="highlight"><c- n>at</c-></code> in terms of <code class="highlight"><c- n>find</c-></code>. We also would like to add a precondition
for <code class="highlight"><c- n>at</c-></code> method that implies the same preconditions that <code class="highlight"><c- n>find</c-></code> implicitly has.</p>
   <p>In case of multiple match this method should return the reference to the same element
as heterogeneous <code class="highlight"><c- n>find</c-></code>.</p>
   <h3 class="heading settled" data-level="3.8" id="summary"><span class="secno">3.8. </span><span class="content">Proposed API summary</span><a class="self-link" href="#summary"></a></h3>
   <p>The proposed heterogeneous overloads for various methos are summarized in the table below:</p>
   <blockquote>
    <div style="text-align: center;"></div>
    <table border="1" class="resize" style="margin: auto;">
     <tbody>
      <tr>
       <th>Member function 
       <th>std::set 
       <th>std::multiset 
       <th>std::map 
       <th>std::multimap 
       <th>std::unordered_set
       <th>std::unordered_multiset
       <th>std::unordered_map
       <th>std::unordered_multimap
      <tr>
       <td>try_emplace 
       <td>Not available
       <td>Not available 
       <td>K&amp;&amp; 
       <td>Not available 
       <td>Not available 
       <td>Not available 
       <td>K&amp;&amp; 
       <td>Not available 
      <tr>
       <td>insert_or_assign
       <td>Not available
       <td>Not available 
       <td>K&amp;&amp; 
       <td>Not available 
       <td>Not available 
       <td>Not available 
       <td>K&amp;&amp; 
       <td>Not available 
      <tr>
       <td>operator[] 
       <td>Not available
       <td>Not available 
       <td>K&amp;&amp; 
       <td>Not available 
       <td>Not available 
       <td>Not available 
       <td>K&amp;&amp; 
       <td>Not available 
      <tr>
       <td>at 
       <td>Not available
       <td>Not available 
       <td>const K&amp; 
       <td>Not available 
       <td>Not available 
       <td>Not available 
       <td>const K&amp; 
       <td>Not available 
      <tr>
       <td>bucket 
       <td>Not available
       <td>Not available 
       <td>Not available 
       <td>Not available 
       <td>const K&amp; 
       <td>const K&amp; 
       <td>const K&amp; 
       <td>const K&amp; 
      <tr>
       <td>insert 
       <td>K&amp;&amp; 
       <td>Not applicable
       <td>Not applicable
       <td>Not applicable
       <td>K&amp;&amp; 
       <td>Not applicable 
       <td>Not applicable 
       <td>Not applicable 
    </table>
   </blockquote>
   <h3 class="heading settled" data-level="3.9" id="perf"><span class="secno">3.9. </span><span class="content">Performance evaluation</span><a class="self-link" href="#perf"></a></h3>
   <p>Our case study with the open-source <a href="https://github.com/pmem/pmemkv"><em>pmemkv</em></a> project confirms the importance of the case with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string_view</c-></code> (see <a href="#dec_implicit">§ 3.7.2 Insertion of implicitly convertible types</a> for more details).</p>
   <p><a href="https://github.com/pmem/pmemkv"><em>pmemkv</em></a> is an embedded key/value data storage for persistent memory that provides several
storage engines optimized for different use cases.
We analyzed <code class="highlight"><c- n>vsmap</c-></code> engine that is built on <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> data structure with <code class="highlight"><c- n>libmemkind</c-><c- o>::</c-><c- n>pmem</c-><c- o>::</c-><c- n>allocator</c-></code> allocator for persistent memory from the <a href="https://github.com/memkind/memkind"><em>memkind library</em></a>. <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>basic_string</c-></code> with the <code class="highlight"><c- n>libmemkind</c-><c- o>::</c-><c- n>pmem</c-><c- o>::</c-><c- n>allocator</c-></code> is used as a key and value type.</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- n>storage_type</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>basic_string</c-><c- o>&lt;</c-><c- b>char</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>char_traits</c-><c- o>&lt;</c-><c- b>char</c-><c- o>></c-><c- p>,</c->
                                       <c- n>libmemkind</c-><c- o>::</c-><c- n>pmem</c-><c- o>::</c-><c- n>allocator</c-><c- o>&lt;</c-><c- b>char</c-><c- o>>></c-><c- p>;</c->
<c- k>using</c-> <c- n>key_type</c-> <c- o>=</c-> <c- n>storage_type</c-><c- p>;</c->
<c- k>using</c-> <c- n>mapped_type</c-> <c- o>=</c-> <c- n>storage_type</c-><c- p>;</c->
<c- k>using</c-> <c- n>map_allocator_type</c-> <c- o>=</c-> <c- n>libmemkind</c-><c- o>::</c-><c- n>pmem</c-><c- o>::</c-><c- n>allocator</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pair</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>key_type</c-><c- p>,</c->
                                                                 <c- n>mapped_type</c-><c- o>>></c-><c- p>;</c->
<c- k>using</c-> <c- n>map_type</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>map</c-><c- o>&lt;</c-><c- n>key_type</c-><c- p>,</c-> <c- n>mapped_type</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>less</c-><c- o>&lt;</c-><c- b>void</c-><c- o>></c-><c- p>,</c->
                          <c- n>std</c-><c- o>::</c-><c- n>scoped_allocator_adaptor</c-><c- o>&lt;</c-><c- n>map_allocator_type</c-><c- o>>></c-><c- p>;</c->
</pre>
   <p>Initial implementation of the <code class="highlight"><c- n>vsmap</c-><c- o>::</c-><c- n>put</c-></code> method was the following:</p>
<pre class="language-cpp highlight"><c- n>status</c-> <c- n>vsmap</c-><c- o>::</c-><c- n>put</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>key</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>value</c-><c- p>)</c->
<c- p>{</c->
  <c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>pmem_kv_container</c-><c- p>.</c-><c- n>try_emplace</c-><c- p>(</c-><c- n>key_type</c-><c- p>(</c-><c- n>key</c-><c- p>,</c-> <c- n>kv_allocator</c-><c- p>),</c-> <c- n>value</c-><c- p>);</c->

  <c- k>if</c-> <c- p>(</c-><c- o>!</c-><c- n>res</c-><c- p>.</c-><c- n>second</c-><c- p>)</c-> <c- p>{</c->
    <c- k>auto</c-> <c- n>it</c-> <c- o>=</c-> <c- n>res</c-><c- p>.</c-><c- n>first</c-><c- p>;</c->
    <c- n>it</c-><c- o>-></c-><c- n>second</c-><c- p>.</c-><c- n>assign</c-><c- p>(</c-><c- n>value</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>value</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->
  <c- p>}</c->

  <c- k>return</c-> <c- n>status</c-><c- o>::</c-><c- n>OK</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>It explicitly creates a temporary object of <code class="highlight"><c- n>key_type</c-></code> when the <code class="highlight"><c- n>try_emplace</c-></code> method is called.</p>
   <p>For performance evaluation, we extended LLVM Standard Library with the heterogeneous overload for the <code class="highlight"><c- n>try_emplace</c-></code> method of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code>.
With such overload the <code class="highlight"><c- n>vsmap</c-><c- o>::</c-><c- n>put</c-></code> method does not need to create a temporary object of <code class="highlight"><c- n>key_type</c-></code>:</p>
<pre class="language-cpp highlight"><c- n>status</c-> <c- n>vsmap</c-><c- o>::</c-><c- n>put</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>key</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>value</c-><c- p>)</c->
<c- p>{</c->
  <c- k>auto</c-> <c- n>res</c-> <c- o>=</c-> <c- n>pmem_kv_container</c-><c- p>.</c-><c- n>try_emplace</c-><c- p>(</c-><c- n>key</c-><c- p>,</c-> <c- n>value</c-><c- p>);</c->

  <c- k>if</c-> <c- p>(</c-><c- o>!</c-><c- n>res</c-><c- p>.</c-><c- n>second</c-><c- p>)</c-> <c- p>{</c->
    <c- k>auto</c-> <c- n>it</c-> <c- o>=</c-> <c- n>res</c-><c- p>.</c-><c- n>first</c-><c- p>;</c->
    <c- n>it</c-><c- o>-></c-><c- n>second</c-><c- p>.</c-><c- n>assign</c-><c- p>(</c-><c- n>value</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>value</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->
  <c- p>}</c->

  <c- k>return</c-> <c- n>status</c-><c- o>::</c-><c- n>OK</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>For benchmarking we used the <a href="https://github.com/pmem/pmemkv-tools"><em>pmemkv utility</em></a> and run the <i>fillrandom</i> benchmark on a prefilled storage
(it means that the <code class="highlight"><c- n>vsmap</c-><c- o>::</c-><c- n>put</c-></code> method updates existing element rather than inserting the new one). We executed the test with different key sizes
(16, 100, 200,  400, 600, 800, 1000 bytes) and measured the throughput as operations per second.</p>
   <p>The chart below shows performance increases relative to the initial implementation:</p>
   <p><img class="resize" src="data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAkACQAAD/4REMRXhpZgAATU0AKgAAAAgABAE7AAIAAAAWAAAISodpAAQAAAABAAAIYJydAAEAAAAsAAAQ2OocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEJveWFyaW5vdiwgS29uc3RhbnRpbgAABZADAAIAAAAUAAAQrpAEAAIAAAAUAAAQwpKRAAIAAAADNTkAAJKSAAIAAAADNTkAAOocAAcAAAgMAAAIogAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIwMjE6MTI6MDMgMTc6MTM6NDYAMjAyMToxMjowMyAxNzoxMzo0NgAAAEIAbwB5AGEAcgBpAG4AbwB2ACwAIABLAG8AbgBzAHQAYQBuAHQAaQBuAAAA/+ELKGh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iLz48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyI+PHhtcDpDcmVhdGVEYXRlPjIwMjEtMTItMDNUMTc6MTM6NDYuNTg3PC94bXA6Q3JlYXRlRGF0ZT48L3JkZjpEZXNjcmlwdGlvbj48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyI+PGRjOmNyZWF0b3I+PHJkZjpTZXEgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj48cmRmOmxpPkJveWFyaW5vdiwgS29uc3RhbnRpbjwvcmRmOmxpPjwvcmRmOlNlcT4NCgkJCTwvZGM6Y3JlYXRvcj48L3JkZjpEZXNjcmlwdGlvbj48L3JkZjpSREY+PC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBlbmQ9J3cnPz7/2wBDAAcFBQYFBAcGBQYIBwcIChELCgkJChUPEAwRGBUaGRgVGBcbHichGx0lHRcYIi4iJSgpKywrGiAvMy8qMicqKyr/2wBDAQcICAoJChQLCxQqHBgcKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKir/wAARCAFVAhADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD6HtraBrSEtDGSUUklBzxUv2S3/wCeEX/fAotP+POH/rmv8qloAi+yW/8Azwi/74FH2S3/AOeEX/fAqWigCL7Jb/8APCL/AL4FH2S3/wCeEX/fAqWigCL7Jb/88Iv++BR9kt/+eEX/AHwKlooAi+yW/wDzwi/74FH2S3/54Rf98CpaKAIvslv/AM8Iv++BR9kt/wDnhF/3wKlooAi+yW//ADwi/wC+BR9kt/8AnhF/3wKlooAi+yW//PCL/vgUfZLf/nhF/wB8CpaKAIvslv8A88Iv++BR9kt/+eEX/fAqWigCL7Jb/wDPCL/vgUfZLf8A54Rf98CpaKAIvslv/wA8Iv8AvgUfZLf/AJ4Rf98CpaKAIvslv/zwi/74FH2S3/54Rf8AfAqWigCL7Jb/APPCL/vgUfZLf/nhF/3wKlooAi+yW/8Azwi/74FH2S3/AOeEX/fAqWigCL7Jb/8APCL/AL4FH2S3/wCeEX/fAqWigCL7Jb/88Iv++BR9kt/+eEX/AHwKlooAi+yW/wDzwi/74FH2S3/54Rf98CpaKAIvslv/AM8Iv++BR9kt/wDnhF/3wKlooAi+yW//ADwi/wC+BR9kt/8AnhF/3wKlooAi+yW//PCL/vgUfZLf/nhF/wB8CpaKAIvslv8A88Iv++BR9kt/+eEX/fAqWigCL7Jb/wDPCL/vgUfZLf8A54Rf98CpaKAIvslv/wA8Iv8AvgUfZLf/AJ4Rf98CpaKAIvslv/zwi/74FH2S3/54Rf8AfAqWigCL7Jb/APPCL/vgUfZLf/nhF/3wKlooAi+yW/8Azwi/74FH2S3/AOeEX/fAqWigCL7Jb/8APCL/AL4FH2S3/wCeEX/fAqWigCL7Jb/88Iv++BR9kt/+eEX/AHwKlooAi+yW/wDzwi/74FH2S3/54Rf98CpaKAIvslv/AM8Iv++BR9kt/wDnhF/3wKlooAi+yW//ADwi/wC+BR9kt/8AnhF/3wKlooAi+yW//PCL/vgUfZLf/nhF/wB8CpaKAIvslv8A88Iv++BUVzbQLaTFYYwQjEEIOOKtVFd/8ec3/XNv5UAFp/x5w/8AXNf5VLUVp/x5w/8AXNf5VLQAUUUUAFFFFABRRRQAUUUUAFFFFAHnnjXxLAPGGm6JNqd/YWaCR717JZVkJ2AxgMqkkc87c9ecYroNHnX/AISae1j16a8SOxhK2M0BDRjAxKZCPmZu4681n61/yVzwz/163P8A6DRpn/JYtb/7B0P8xQBzkes6mfgzol8dRuvtct+qSXHnN5jr57jBbOSMAD6V32reLNE0O6Ntqt+tvMIhNsKMSVLFRjAOTkHgc8ZxivNY/wDkhOgf9hFf/SiSuumtobj43wtPEsjQaD5kZYZ2N55GR74Yj8aANe58a+HrSC2lm1FcXUQmhWOJ3dkP8W1VLAfUVYTxNo8nh99bjvkfTowS86KTtwcHKgZz7YzXN6vrly3jm50qyvdN0Mw2qSS313CHknByQq5KjaM9z61zVhJ5vwl8ZuLhLkNqc5E8abFkB8s7gvYHrjtmgDvofHfhq41RNOh1aJrmRtiLtbazf3d2NufbNWta8UaN4dMQ1i+W3abPloEZ2bHfaoJx71yHjK2gtPhRpht4I4/Ie0kj2qBtbIyfqcn86sPe2emfGS7m1qaK2WXTUFnNcMFXhvmCseAetAF/wrraa14w8RyWd+13YLHZm3AkJRMo+7aD0JI59xzVqb4heFbe8a1l1iISK2xmVHZAfTeBt/Wua0ae21LVfH8nhjawmtYRA0K4Dy+VKMj1y3fvSaVrnhm3+D/2Oa5tY2WyaKa0dh5jTYII2dSS3I4/HjNAHcal4i0nSPs39pX0cC3Su0LNkq4VdxO4cdPXr2zWdD8QPC09pPcx6xCI4CA4dWVsnphSAzfgDXHfYJBF8OLPV4d7Ayb4phnHyKVBB9Bjj2roprC1l+NEM0tvG8iaKZVYryHEwUN9cEjNAHRaNr2meILRrnR7tbmJW2MQCpU+hUgEfiKw/Huoy6ZDoEsd29pG+t2yTusmwGI7iwY/3eOc8cVF4YRYviR40jjG1N1m+0dNzRMSfxNQfFJ7WPStCfUFDWia3btOGXcDGFctkdxjPFAG5pXjLw/rd+bLTNSjmuNpYRlGQsB3XcBu/DNLqvjHQdFvDaajfhLhVDPGkTyFAehbYDt/HFcx4h1DTNZ8YeEYtAube7uYbkys1s4by4APmBI6DA6VnaD/AGhBr3iWFvEtlo90dSkeSK6s1dpYz9xwzOvy46DnH40Aeg3HiHSbXSoNSmvYxZXDqkU65ZWLHA6A/wD1u9VNN8a+HtX1P+z9O1OOa5IJVNjKHx12kgBunYmuF1vSLbTvhXa2tvqMWq2smrKwmiQLGQZCGVQCRgEHoa6HxrDFba34Pa3iSMx6osSbVA2oRgqPQcCgDb1jxjoOgXS22q6ikM5Xd5ao0jAepCg4H1rB8T+JIYda8J31tqnlaXcSzPNIspWORAgxu9ceh71B4b1HT9I8ceK11y6t7O9kuVkje5cJvgx8u0nsPSk8R/2ZqniHwQbNIJ9PluZ2RVQbGwoPTHqM0AdTovivRPEM0sWj363EkIy6bGRgPXDAEj3qlcfELwtakifVkVhI0ZXypCVKnacgLwM8ZPHvVC/CxfGbSXjUK02mSrIwHLANkZqh4GsrWTwv4md4I2ea/u45GK8uoHAJ9OT+dAHRTePfDFveRW0ms2/mShSpUMyjcMjLAbVyPUitDV/EGl6EkbardrAZSRGm1nd8dcKoJP5V5+tnbJ+zy5SCNS9r5rEKPmfzPvH39609R1y5gvvDum2stjYXFzp4kOp3sYcoMDKJkjk4yQT6UAdXp3iPSdW0+e90+8WaC3z5x2srR4GTlSAw49qrad4z8P6tqENjp2orPczR+YiLG4yMbupGAcc4PPtXHeGZWm1Px87ajDqR8iHN1BGI0kIikBwoJHBGM55xmuk+GsEUHw80ryY1TzIy77RjcxY5J9TQBQ8F+J4LL4Z6VqPiPUZGkmeSPzZS0skrec4AAGWY4A6dhXbqdygjOCM8jFeLeCz/AGJa+G9b1wfatIkSa3gkb7unTGZ/mI6YbH3jyPwGfZLsSvYTi0YCZom8o5/ixx+tAGFeeP8AwvYXz2l1q0azRttfZG7qh9CyggH6mtK+1/S9Nsra7vb2OO2upFjhm5KOWBI5HAGATk8VxPgzW/DWnfDb7Lq1xbQyxLKt/azMBKz7jkFTySRjH5dqy/sEn/CsvA1nqsJbzdbgDxSj70bvKQCPQqRQB6BpHjHQNdvms9K1FJ7hVLeXsZCwHddwG4fTNat3dQ2NlPd3T+XBbxtLI+CdqqMk4HPQVyPilUtvH/g2WFFR/NuIshcfIYwMfTk/Stzxd/yJOuf9g64/9FtQBUPxB8LC6it/7Yh8yXbtOx9uSMgFsYU+xIIq7q3ijRtCnEOrXy20jRGYKyMcqDjjAPOT06159daz4cf4JJYW09qblrSKP7KmBIbjC5Ozrndk571qfYyfiN4Si1GNZJ4NIJYOM7ZFHX6g96AOpm8YaDb6Ta6lNqCrbXZItz5bl5CDg4TG4478cU0eL9Gm0G61WzuxPBa8SBY33qxOACmNwySO1cr4mF3D8WLKb+1oNJjk0wx21zc24kTfv+ZBlgAxB656cd6vaNpix6rr2pN4jtdXuprNUuEtYFjCcNtLbXYZwCPWgDI8Kaul/wCEr7VLnxPqcGpm1ke6klSSSC2BfhkQrtJAAGFPc/hsarqF1FrXgdLfUpporov50q5jF0PKUhmT3znB6ZrL07/k3l/+vGb/ANDapbv/AI/vhv8A9cz/AOiEoA2fC99cz+MPFkV1cyyQW1xCIkkkJWIFDnaDwB9KuQ+O/DU96lrFqsbSO/lo2xxGzZxgSEbT+dcm0V1PJ8SY7AMZ2CBQvU/u2yB7kZqnDaLrHw/tbO68b6Xb6e0EYMH2FA8TDB2/6wHcCPTJ/GgD0PWvFGjeHTENYvlt2mz5aBGdmx32qCce9Y/hXW01rxh4jks79ruwWOzNuBISiZR920HoSRz7jms1bq00j4uzvrtzHEH0uNLS4uWCqcH5sMeASc1P4IutOvfHHi240YxtaubUholwrttk3EeuTnnvQB3NFFFABRRRQAUUUUAFFFFABRRRQAVFd/8AHnN/1zb+VS1Fd/8AHnN/1zb+VABaf8ecP/XNf5VLUVp/x5w/9c1/lUtABRRRQAUUUUAFFFFABRRRQAUUUUAQvZ20l3FdSW8T3EIIjmZAXQHqAeozQtnbJePdpbxLcyKEeYIA7KOgLdSKmooAp/2RposY7Iafa/ZY23pB5C+WjZzkLjAOST9an+yW/wBt+2fZ4vtXl+V5+wb9mc7d3XGecVLRQBTvdI03UnR9R0+1u2j+408CuV+mRxSjStOFrNaiwtRb3DFpohCuyQnGSwxgngdfQVbrKi8UeH55Vih1zTZJGOFRLuMkn6ZoAuz2FndWq2tzaQTW642xSRhkGOnB44pt9pdhqaImpWNteKhyouIVkCn2yOKL3U7DTfL/ALRvba0807Y/PlVN59Bk81aoAgt7C0tJHe0tYIHkVVdoowpYKMKCR1AB49KrtoOkPffbX0qya6zu8826F8+u7Gamh1Oxub2Wzt723luof9bAkqs8f+8oOR+NVJvFGgW87w3GuabFLGxV43u41ZWHBBBPBoAvTWdtcTwzT28UssBJhkdAWjJGCVJ6fhS/Zbf7Z9r8iL7SI/K87YN+zOdu7rjPOKrTa3pVvaQ3VxqdnFb3H+pme4VUk/3STg/hV4HIyORQBFHaW8NzNcRW8Uc9xt86VUAaTaMLuPU4HAz0ontbe68v7VBFN5TiSPzEDbGHRhnoeTz71HFqdjPfSWUF7byXcQ3SW6SqZEHHJUHI6j86fBeW108yWtxDM0D+XKsbhjG391sdD7GgCGz0jTdOkeTT9PtbV5PvtBAqFvqQOaS90XS9SkWTUdNs7t14Vp4Fcj6EiiLWtLnljih1Kzkkldo40SdSXZcFlAzyRkZHbNWbi5gtLd57uaOCGMZeSRgqqPUk8CgCKTTbGa1S1ms7eS3jIZImiUopHQgYwMU+eztrp4XureGZoH8yJpEDGNv7y56H3FSRyJLEskTq6OAyspyGB6EGs6HX7S41jUNOjWUvp0aPcTbR5a7hkLnOc4GcYoAnvdH0zU3R9S060u2j+408CyFfpkcVI2n2bPbs1pAWtc+QTEMw5GPl4+Xj0pumanaaxpsN/ps3nW0wJjk2ldwBx0IB6g0txqNnaXVtbXVzFDPdMVgjdgDIR1A9eo/OgB7Wds94l29tC1zGpRJjGC6qeoDdQPakgsbS1ikitrWGGOVmeRI4wodj1JA6k9zU9VNQ1Wz0v7L9vm8r7XcJbQ/KTvkbO1eBxnB5PFADv7Nsf7O+wfYrf7Ht2/ZvKXy8em3GMU270nTr+3jgvrC1uYY/uRzQq6p9ARgVbooAqwaXp9qJRbWNtCJlCSCOFV3qAQAcDkAE8e9TW9tBZ26W9pDHBDGMJHEgVVHoAOBUlFAFUaVp403+zxYWwssY+zCFfL65+7jHXn61YjjSKNY4kVEQBVVRgKB0AFQPqNnFqUWnyXMS3kyF44Cw3so6kCrNAFCfQtIubz7Xc6VZTXOc+dJboz/99EZq1cWlvd+V9qt4p/JkEsfmIG2OOjDPQj1p8kixRtJIcKgLMfQCq+manaaxpsN/ps3nW0wJjk2ldwBx0IB6g0ASTWdtcTwzz28UstuSYZHQFoyeCVJ6Z9qra7Yyan4d1GwgZVlurWWFGckKGZCoJx25q/RQBiaL4asdP03TftVhZSajZ2sULXSwqW3IgXIYjOOK1Ws7Z7xLt7eJrmNSiTFAXVT1AbqBU1FAEF5YWmoweTqFrBdRZzsnjDr+RptpptjYQNBY2VvbQt96OGJUU/UAVZooArLp1imn/YEs7dbPaU+zCJRHtPUbcYxSnT7Nmtma0gJtf+PcmIfueMfJx8vHHFVr7W7bT9Y0/TrlJVfUC6wygDZuUZ2k5yCR045rRoAhhs7a3nmmgt4opZyDNIiANIQMAsR1/Gqo0DRxefaxpNiLndu84Wyb8+u7Gc1oUUAVb7S7DU0RNSsba8VDlRcQrIFPtkcU+3sLS0kd7S1ggeRVV2ijClgowoJHUAHj0qeigAooooAKKKKACiiigAooooAKKKKACorv/jzm/wCubfyqWorv/jzm/wCubfyoALT/AI84f+ua/wAqlqK0/wCPOH/rmv8AKpaACiiigAooooAKKKKACiiigAooooAKKKKACiiigArxDRtR8Jy/CtNLuLSK812SKVI4orUtP5hdvLO8L2yvfpx7V7fXOeANJvdD8Dafp2pw+TdQ+Zvj3BsZlZhyCR0IoA4zxNodxf2PgjRdXbNzLDNDIznJV/JXGT6g4/Kuh0Txf9m+Gcupaj/x+aUjW1xG3UzJ8oB9z8v51f8AEekXt/4r8NXlpDvgsZ5XuH3gbAyADgnJ5HbNYmo+CdQuPiD5kIH/AAj93NFfXi7h/rowwC4zkhiQT2/IUAUPAWlTaR8QJor0k3k2jrcXTHqZXl3Nn3GcfhUWhX+l2upeJE1Dwve6vIdcuiJ7fTBcKoyPl3dj1OPf3rr7fSL2P4nXmrvDixk01IEl3jlw4JGM56d8YrH0ceKPDl5rcUHhZ7+G81We8imW/hjyjkY4Jz0GfxoAg+IOmW2qSeFdOWAW9vc3DxiLy9vlho+Pl7EZ6e1aHhrxR9i+HdxcaucXWhh7W6QnkvHwo/4F8oz6mp9Z07Vta1DwtfHTjbtaXZmu4jOjeQMY65+b8M1ma34J1C98erLagf2FfyRXGorvABkizhduckNx0FAGf4H02fTviLFJfEm+vtBa8uie8klzn9BgfhWfDqd03iLW/DljMbKTWNamR75uBGgA3Kvq5zgf/Xrvv7Jvf+Fo/wBr+T/oP9jfZfN3D/Wedu24znpznGKxrfwRLqMHia21eI24vNTa6sbhXBZDj5ZBg5HPY4OM0AJ4y8PwaD4PsLzQoPLbw/OlzGoPLpnD5PfPUn2qfxtdpr2n6Jodi7FdenR2Zeot1Adj+W39a2dBi1S+8MvY+LLQJc7Wt5mWRWW4TGN4weMg9Dg57VzngTwrrOm6w0/iFF8vTbY2WnuHVvMQyMxfAJxxtHODigDv0RY0VI1CqowqqMAD0rhvAzfa/Cuu6o/Mt/e3Mpb/AGQMAfQYruq4bwLC1vpPiHQf+W9lfToqnjKOMofx5oAwPC+s+KtL+Glvf6dp2ntpthE7ss7uZp0DsWZdvCgc9c9Ca6rVNdjl1nwg8djazJqbO6yTxbpIAY1YFG/hPPP0pmkaDqVr8IZNEnt9uotYXEIh3qfnbftG7OO471CfDuqFvAv+jf8AIJiC3v7xf3R8lV9eeQRxmgB134l8RX0+tv4dg01LXR3aJzeiRnmdV3NgKQFHbnrWJr+s6lqfgnwprFzBBcXUut200UFsDGH4fCfMTg5GM9KpQaZqus6t4hutLt725sri/likNtqSWizKoA2FCjZwON2RnNb2P+Es8M+GZfD2nm3g07WYGmty6jyI4twbBJ+bGR0yTQBoWniDxFY+KtP0vxNaacsWppIbeSyd8xui7irbuvHpiobnxdqV9rmoWWhy6PaQ6fJ5MkupyNmWTuFVSMAdMnNX/EekX1/4r8NXlpDvt7GeV7h96jYCoA4JyeR2zWFJ4Vn0rxFqtz/witj4jtdRnNzG8hiWSBm+8p8zqM88GgCxc/EG4Hw/fXba0iF3Bdi1nhJLpuDgNtIIzkHI+veuk0GXxBNHLJ4igsbcOFaCK1ZmeMHOVcngkfLyOOtc5r3h7UNR+HxsLDRLPT7p7pJfsVo6BVUOOS2FUtgc13VAHM32oiL4laXp/wBitHM1nLJ9qeLMyYP3VbsD3FUtC8S654i1KZrI6RBaW92YZbSYubpY1bBY4OASOgxj3q7faRfTfErS9VjhzZW9nLFJLvX5WJ4GM5P5Vg6zouseINStZ4fDCaPfx3CO2qrexkhAeeF+ZsjjBFAHeaj/AMgu6/64v/6Ca8z8Jap4ssfhva3ml6fpx0+yhd9txI5muFDMWK7eF7gA5Jx9K9OvI2msZ44xlnjZVHqSK860qy8b6X4HXw6mhWztJA8SXf2xAIA+c715yRk4K8dPxANnUPHe+x0T+xkthd6zGZUN7Jtit0UZYuR154AHU0uleKNTudaudCvH0uW/a0a4s7qzZmgY5xtdckgg4PXkVn6l4EltLXw7NY2NrrD6RCYJ7O62hbhWHJBYYBDEkZ9fatrw5YNHqUk7eELDQUWIqskZiMzkkcfuxgLgevpQBzfw+XxMdN1T7DNpQj/tG43efFIW83jJGG+7nHHX3qT4Z3Op2XhF7u8ls/7Jga4kcLG/nAhiSc5244PatbwjYa3oGp3+m3Glq+n3F9NdJqC3K/dbkDy/vZ4A/H25q+F9D1mx0W/8L6ppipYSi4VdRS4Vg4kzjEfXueuKAKp8ea0dFOvquiCxA80ae1w32ox5/vZ27sc4xWlq/i3Vv7e0rTvDlpbXH9qWX2iN7ncvl8g7mIP3QucgDJOMVkaZ4cvdK0yPTbjwFpOpXEA8tdQZ4Ako7MwYb8+vBroJtEvf+FgaNqMNrGljaWEkEjRsoWNj0UL1x9BQBn+PDqFt4EtdU1L7MNQ0y8huXa13eWCJNvy7ucEMOK7quN+JebvQrHR4uZdUv4YAg7qG3MT7DaK7KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKiu/+POb/rm38qlqK7/485v+ubfyoALT/jzh/wCua/yqWorT/jzh/wCua/yqWgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKpxaVZQatcanFDsu7lFjmkDH5wv3cjOMj1xmrlFABRRRQBz134D8N3t5Ncz6diWdt0vlTyRrIe5KqwB/KtqysrbTrKK0sIEt7eIbUjjXAUVPRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAVJ9Ls7rU7XULiHfdWYcQOWP7vcMNgZxkgdcVboooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACorv8A485v+ubfyqWorv8A485v+ubfyoALT/jzh/65r/KpaitP+POH/rmv8qloAKKKKACuVuRqNt8SNM87U5ZLW7guStog2RxhBHjIz8zZZjuPtgDv1VYl34ca81uDVG1jUI5bfeIY0WDZGr7dy8xkkHaOpJ9DQBY8QalJpul5tFEl7cuLe0jPRpW6Z9gAWPsprN8DG5XSr6C8vZ72S21GeATXDlmYK2B16fTpWi3h2wnNx/aaHVEmnM6x34WZYCQBiMEfKOOnuaND8Oab4eW6Gl26RfapmlkIRV6kkKNoHyrk4HbNAGpTHmiiIEkiIT03MBT6KAIvtdv/AM94v++xR9rt/wDnvF/32KlooAi+12//AD3i/wC+xR9rt/8AnvF/32KlooAi+12//PeL/vsUfa7f/nvF/wB9ipaKAIvtdv8A894v++xR9rt/+e8X/fYqWigCL7Xb/wDPeL/vsUfa7f8A57xf99ipaKAIvtdv/wA94v8AvsUfa7f/AJ7xf99ipaKAIvtdv/z3i/77FH2u3/57xf8AfYqWigCL7Xb/APPeL/vsUfa7f/nvF/32KlooAi+12/8Az3i/77FH2u3/AOe8X/fYqWigCL7Xb/8APeL/AL7FH2u3/wCe8X/fYqWigCL7Xb/894v++xR9rt/+e8X/AH2KlooAi+12/wDz3i/77FH2u3/57xf99ipaKAIvtdv/AM94v++xR9rt/wDnvF/32KlooAi+12//AD3i/wC+xR9rt/8AnvF/32KlooAi+12//PeL/vsUfa7f/nvF/wB9ipaKAIvtdv8A894v++xR9rt/+e8X/fYqWigCL7Xb/wDPeL/vsUfa7f8A57xf99ipaKAIvtdv/wA94v8AvsUfa7f/AJ7xf99ipaKAIvtdv/z3i/77FH2u3/57xf8AfYqWigCL7Xb/APPeL/vsUfa7f/nvF/32KlooAi+12/8Az3i/77FH2u3/AOe8X/fYqWigCL7Xb/8APeL/AL7FH2u3/wCe8X/fYqWigCL7Xb/894v++xR9rt/+e8X/AH2KlooAi+12/wDz3i/77FH2u3/57xf99ipaKAIvtdv/AM94v++xR9rt/wDnvF/32KlooAi+12//AD3i/wC+xR9rt/8AnvF/32KlooAi+12//PeL/vsUfa7f/nvF/wB9ipaKAAHIyORUV3/x5zf9c2/lUtRXf/HnN/1zb+VABaf8ecP/AFzX+VS1Faf8ecP/AFzX+VS0AFFFFABULXdsl2lq9xEtxIpdIS4Dso6kL1IqauSvNNtLP4maPdW8W2e7gu2nkLFi+FiAHJ4AHQDgZPrQB093eW1havc31xFbQJjdLM4RVycDJPA5IFFpeW1/apc2NxFcwPnbLC4dWwcHBHB5BFUdS1fSLezluryaCZbKYKVXEjpN2UKOd/PA681X8K6fcWdhdXF7EIJ9Ru5Lxrcc+TvwAhPc4UE+5P1oA3KKKY5lBHlojDvucj+hoAfRUW64/wCeUX/f0/8AxNG64/55Rf8Af0//ABNAEtFRbrj/AJ5Rf9/T/wDE0brj/nlF/wB/T/8AE0AS0VFuuP8AnlF/39P/AMTRuuP+eUX/AH9P/wATQBLRUW64/wCeUX/f0/8AxNG64/55Rf8Af0//ABNAEtFRbrj/AJ5Rf9/T/wDE0brj/nlF/wB/T/8AE0AS1n3+u6dpk6w31x5UjLvA2M3GSOw9jVvdcf8APKL/AL+n/wCJrgvHJc65D5iqp+zLwrZ/ib2FAHUf8Jdof/P7/wCQn/8Aia14ZkuII5oW3RyKHU4xkEZFeN16to7T/wBh2O2OMj7NHgmQj+Ef7NAGjRUW64/55Rf9/T/8TRuuP+eUX/f0/wDxNAEtFRbrj/nlF/39P/xNG64/55Rf9/T/APE0AS0VFuuP+eUX/f0//E1xd9411K11G5t1gtdsUrIMqx6EjruFAHc0Vw1j411K61G2t2gtdssqocKw6kDruNdpuuP+eUX/AH9P/wATQBLRUW64/wCeUX/f0/8AxNG64/55Rf8Af0//ABNAEtFRbrj/AJ5Rf9/T/wDE0brj/nlF/wB/T/8AE0AS0VFuuP8AnlF/39P/AMTXCf8ACeap/wA8LT/vhv8A4qgD0CiuO0XxdqOp6xBaSQWoWTdnaGU8KT1yfT0rrN1x/wA8ov8Av6f/AImgCWiot1x/zyi/7+n/AOJo3XH/ADyi/wC/p/8AiaAJaKi3XH/PKL/v6f8A4mjdcf8APKL/AL+n/wCJoAloqLdcf88ov+/p/wDiaN1x/wA8ov8Av6f/AImgCWiot1x/zyi/7+n/AOJo3XH/ADyi/wC/p/8AiaAJaKi3XH/PKL/v6f8A4mjdcf8APKL/AL+n/wCJoAloqLdcf88ov+/p/wDiaN1x/wA8ov8Av6f/AImgCWiua8ZXd5a6PE8Lm3YzgboZSCflbjoOK4r+2dU/6CV3/wB/2/xoA9aormvBt3eXWjyvM5uGE5G6aUkj5V46Hiug3XH/ADyi/wC/p/8AiaAJaKi3XH/PKL/v6f8A4mjdcf8APKL/AL+n/wCJoAloqLdcf88ov+/p/wDiaN1x/wA8ov8Av6f/AImgCWiot1x/zyi/7+n/AOJo3XH/ADyi/wC/p/8AiaAJaKi3XH/PKL/v6f8A4mjdcf8APKL/AL+n/wCJoAlqK7/485v+ubfyqUdOetRXf/HnN/1zb+VABaf8ecP/AFzX+VS1Faf8ecP/AFzX+VS0AFFFFABWbN4c0S4u2urjRtPluGbc0z2qM5PruIzmtKigCjPomlXUckdzplnMksvnSLJboweTGN5BHLY4z1qSw0rT9LR00yxtrNXOXFvCsYY++AM0mp3x06we4S1uLtwQEgt03O7E4A9h6k8AVB4e1c694ftNTMH2c3KbjFv37eSMZwM9PSgDSooooAKKKKACiisXxD4h/sH7P/o3n+du/wCWm3bjHsfWgDaorjP+Fg/9Qz/yY/8Asa6bSNQ/tXSobzyvK83d8m7djDEdcD0oAu0UUUAFFFFABXn/AI8/5D0P/Xsv/oTV6BXn/jz/AJD0P/Xsv/oTUAcxXrWjf8gGw/69o/8A0EV5LXrWjf8AIBsP+vaP/wBBFAF2iiigAooooAK8l1n/AJD1/wD9fMn/AKEa9aryXWf+Q9f/APXzJ/6EaADRv+Q9Yf8AXzH/AOhCvWq8l0b/AJD1h/18x/8AoQr1qgAooooAKKKKACvGK9nrxigDa8I/8jVZ/wDA/wD0Bq9NrzLwj/yNVn/wP/0Bq9NoAKKKKACiiigDJ8UTS2/hu6lt5HikXZh0YqR869xXnf8AbOqf9BK7/wC/7f416B4u/wCRVvP+Af8Aoa15lQB3Xga9urv7d9ruZp9vl7fNkLYzuzjNdbXGfD7/AJiH/bL/ANmrs6ACiiigAooooA5nx5/yAYf+vlf/AEFq8+r0Hx5/yAYf+vlf/QWrz6gD0HwH/wAgGb/r5b/0Fa6auZ8B/wDIBm/6+W/9BWumoAKKKKACiiigAorj/Fuu6jpmrRQ2Nx5UbQByNitzuYdx7CsL/hLtc/5/f/ISf/E0Aem0VW0yZ7jSbSaZt0kkCOxxjJKgmrNABUV3/wAec3/XNv5VLUV3/wAec3/XNv5UAFp/x5w/9c1/lUtRWn/HnD/1zX+VS0AFYT+NNDj1I2T3Thlk8lpfIfylkzjaZMbQc++K3a8wvdQjFpeaJF4r0CK0kuXPkvE5kTMm5o87+mcjpnng9KAPT6KqaauorakaxLayz7jhrWNkXb24Zic9e9W6AILy4ktrcyQ2k144IHlQFAx/77ZR+tYvgi3vrDwta6fqVhNZzWqbT5jxsHyScqUZv1xXQ0UAFMeJZCCxcY/uuV/kafRQBF9mT+9L/wB/W/xrhvGus6jpGtRQafeSwxNbq5XO7J3MM859BXfV5p8Rv+Rig/69F/8AQ3rzcynKGHbi7O6PTyuEKmJUZq6s9zL/AOEt13/oIy/kP8K3vFDNLouhTyuzyzW5d2ZickqhJ9uvauIrtvEn/Iu+Hf8Ar0/9kjrhymtUqTkpyb06s9DOKNKnTi4RS16I5qvSfCcCv4XtGJkyd/SRgPvt2BrzavTfCP8AyKtn/wAD/wDQ2r6A+cNX7Mn96X/v63+NH2ZP70v/AH9b/GpaKAIvsyf3pf8Av63+NeYat4m1m21q9ggv5ViiuJEReDgBiAORXqleLa7/AMjFqX/X3L/6Ga8bNqk6cIuDa16Ht5PSp1KklOKenU1dJ8Tazc61ZQT38rRS3EaOvAyCwBHArS8coI9chClj/oyn5mJ/ib1rmNC/5GLTf+vuL/0MV1Pjz/kPQ/8AXsv/AKE1GU1J1ISc23r1DOKVOnUioRS06HMV6to9ujaHYkmTm2jPErD+Ee9eU161o3/IBsP+vaP/ANBFeyeIWPsyf3pf+/rf40fZk/vS/wDf1v8AGpaKAIvsyf3pf+/rf415L/wluu/9BGX8h/hXr9eD14eb1alPk5JNb7P0PfyalTqc/PFPbdX7nX+F9f1XUfElra3l7LJDJv3LkDOEYjkc9RWbrA265fAZ4uZByc/xGl8E/wDI4WP/AG0/9FtRrP8AyHr/AP6+ZP8A0I1vlVSdSg3N316+iOfN6cKddKCSVunqxNHG7XLEHPNzGODj+IV6t9mT+9L/AN/W/wAa8q0b/kPWH/XzH/6EK9ar1TyCL7Mn96X/AL+t/jR9mT+9L/39b/GpaKAMPxRLLp3hu6urOaWOaPZtbzCcZdQeCcdDXnn/AAluu/8AQRl/If4V6D42/wCRPvv+2f8A6MWvJa+bzWtVp10oSa06PzZ9PlFClUoNzim79V5I9G8Dale6x9u/tK6lm8ry9nzbcZ3Z6Y9BXFV1fwz/AOYn/wBsv/Z65SvWy+Up4aMpO71/NnkZjCMMVKMVZafkjZ8JqH8UWinODv6Eg/cbuK9J+zJ/el/7+t/jXm/hH/karP8A4H/6A1em13HnkX2ZP70v/f1v8aPsyf3pf+/rf41LRQBzHjW7udI0WKfT7iWGVrhULby2RtY45z6CuH/4S3Xf+gjL+Q/wrsviN/yLsH/X2v8A6A9eaV8xmVerDENRk0rLqfV5XQo1MMpTim7vdI7m2vrnVPh9qFzfzyTSpcKgJbAxmM4wOO5rl66DR/8Akmep/wDX2P5x1z9e5g5OWHg5O7seBjYxjiZxirK52PgGNZPt+4sMeX91yv8Ae9K7H7Mn96X/AL+t/jXI/D7/AJiH/bL/ANmrs66zjIvsyf3pf+/rf40fZk/vS/8Af1v8alooA4HxrrOo6RrUUGn3ksMTW6uVzuydzDPOfQVz3/CW67/0EZfyH+FanxG/5GKD/r0X/wBDeuSr5HGYitHETUZtK/dn2WCw1CWGhKUE3bsj0PxGWm8E6ZcSu7yymJ3ZnJyTGSTjp1rja7LX/wDkn+j/AO7B/wCijXG19VTbcE32PkaqSqSS7ne+BoVk0OYsXH+ksPlcj+FfQ10v2ZP70v8A39b/ABrnvAf/ACAZv+vlv/QVrpq0MyL7Mn96X/v63+NH2ZP70v8A39b/ABqWigDzbxRr+q6d4kurWzvZY4Y9m1cg4yik8nnqayf+Et13/oIy/kP8Kl8bf8jhff8AbP8A9FrWDXxuJxNeNeaU3u+r7n22Gw1CVCDcFey6Lsdt45QR65CFLH/RlPzMT/E3rXNV0/jz/kPQ/wDXsv8A6E1cxX2R8SeraPbo2h2JJk5tozxKw/hHvVz7Mn96X/v63+NV9G/5ANh/17R/+girtAABgYqK7/485v8Arm38qlqK7/485v8Arm38qAC0/wCPOH/rmv8AKpaitP8Ajzh/65r/ACqWgCrfanYaXGsmp31tZo52q1xMsYY+gJIri9T1s6zG9jL4g8KxW0kqlZY77dKgDAhlBIG/jjnrXdywRTqBPEkgByA6g4/OvPZ7Cdft2gxQaKzC4a5fUGu1EsCGTcHaPG4MvCjnHA7cUAei155dXl7L4b1XxIt/eR3lpqTrDGtwwhWNJRH5ZjB2MCAckjOT14r0OsCTwhZSXExN1dizuLr7ZNYB18mSXIOT8u/BYBtu7Ge1ADPG93PZ6FFJbyyqPtcSyQ27lZrlM8xRFfm3n2wcA8jrUXgq7a6h1LdNdBEuysdlfSM9xartHDlsn5jlhyRgjBNXbrwxDd72lv7/AM77YLyCbzQzWrgYxGGBAXGRtII5PtizpWixaXLdT/aLi7ubx1ee4uCu59owowoVQAPQCgDRpjyrGQGDnP8AdQt/IU+igCL7Sn92X/v03+Feb/ENxJ4hgKhh/oqj5lI/jf1r02vNPiN/yMUH/Xov/ob15ea/7s/VHrZR/vS9GclXaeInDeHvD4Ab5bXBypH8CevWuLrtvEn/ACLvh3/r0/8AZI687Jv4kvQ9LO/4cPU5qvSfCc6p4XtFIkyN/SNiPvt3ArzavTfCP/Iq2f8AwP8A9DavpT5c1ftKf3Zf+/Tf4UfaU/uy/wDfpv8ACpaKAIvtKf3Zf+/Tf4V41rh3eIdRIzzdSnkY/jNe1V4trv8AyMWpf9fcv/oZrws5/hw9T38k/iT9BNDO3xDpxOeLqI8DP8YrqPHLiTXISoYf6Mo+ZSP4m9a5jQv+Ri03/r7i/wDQxXU+PP8AkPQ/9ey/+hNTyb+HL1DO/wCJD0OYr1bR7hF0OxBEnFtGOImP8I9q8pr1rRv+QDYf9e0f/oIr3DwCx9pT+7L/AN+m/wAKPtKf3Zf+/Tf4VLRQBF9pT+7L/wB+m/wrwyveK8Hr57Ov+Xfz/Q+jyP8A5efL9Td8GME8XWTHOB5nQEn/AFbdhRrB3a5fEZ5uZDyMfxGl8E/8jhY/9tP/AEW1Gs/8h6//AOvmT/0I105P/Afr+iOfOv8AeF6fqxNHO3XLEnPFzGeBn+IV6t9pT+7L/wB+m/wryrRv+Q9Yf9fMf/oQr1qvYPEIvtKf3Zf+/Tf4UfaU/uy/9+m/wqWigDnfGc6v4RvVAkyfL6xsB/rF7kV5TXrXjb/kT77/ALZ/+jFryWvls4/jr0/Vn1mS/wC7v1/RHc/DaRY/7S3BjnyvuoW/v+lcvXV/DP8A5if/AGy/9nrlK9nLf90h8/zZ4uaf75P5fkjZ8JsE8UWjHOBv6Ak/cbsK9J+0p/dl/wC/Tf4V5v4R/wCRqs/+B/8AoDV6bXoHmkX2lP7sv/fpv8KPtKf3Zf8Av03+FS0UAcf8Q5lk8PQBQ4/0pT8yEfwP6ivN69L+I3/Iuwf9fa/+gPXmlfJZr/vL9EfY5R/uq9WdfpDgfDfUkw2TdA/dOOsffpWDXQaP/wAkz1P/AK+x/OOufr6HA/7tD0Pm8f8A71P1Ox8AyLH9v3Bjny/uoW/veldj9pT+7L/36b/CuR+H3/MQ/wC2X/s1dnXYcRF9pT+7L/36b/Cj7Sn92X/v03+FS0UAeZfENxJ4hgKhh/oqj5lI/jf1rlK634jf8jFB/wBei/8Aob1yVfFY7/eZ+p91gP8AdYeh6Brsit4D0hQGyFh6oQP9Ue9chXZa/wD8k/0f/dg/9FGuNr7Gl/Dj6I+Jq/xJerO98DTLHocwYOf9JY/KhP8ACvoK6X7Sn92X/v03+Fc94D/5AM3/AF8t/wCgrXTVoZkX2lP7sv8A36b/AAo+0p/dl/79N/hUtFAHknjNg/i69YZwfL6gg/6texrCre8bf8jhff8AbP8A9FrWDXw2K/jz9X+Z99hP93p+i/I7bxy4k1yEqGH+jKPmUj+JvWuarp/Hn/Ieh/69l/8AQmrmK+5PgT1bR7hF0OxBEnFtGOImP8I9qufaU/uy/wDfpv8ACq+jf8gGw/69o/8A0EVdoAAcjNRXf/HnN/1zb+VS1Fd/8ec3/XNv5UAFp/x5w/8AXNf5VLUVp/x5w/8AXNf5VLQAV5lPo12utX+mwyaUY3imW4ujeKJUjlmWQvJHjO4AbeTg8cjpXpteY3GlXKeIbjR4ptJzdrNE85vVE7LLMJCzRY3M4A2+h45HSgD06smbxPpFvfG1lumDrMIGcQuYlkOMIZAuwNyOCc8itavM7ieIeFda8PyOp1m41aQR2hP72TdMHWQL1K7cNu6AA+lAHot7e22nWcl3ezLDBEMu7du34kngAcknFMsdQh1GNnt0uUCnBFxayQH8A6gn6iuX8XajbahZ25s714o9N1iFb6ZI/wDj3wD8x3KV4LIckEDv0rQ8LalPf3WqIL86nYQTItrfMqDzMoC65QBWCt3A745xQB0VFFMcSkjy3RR33IT/AFFAD680+I3/ACMUH/Xov/ob16NtuP8AnrF/36P/AMVXm/xDDjxDB5jKx+yryq4/jf3NeXmv+7P1R62Uf70vRnKV23iT/kXfDv8A16f+yR1xNdp4iDjw94f3spH2X5QFxj5E9+a87Jv4kvQ9LO/4cPU5yvTfCP8AyKtn/wAD/wDQ2rzKvSfCazHwvabJIwvz4BQk/fb3r6U+XN6iottx/wA9Yv8Av0f/AIqjbcf89Yv+/R/+KoAlrxbXf+Ri1L/r7l/9DNeybbj/AJ6xf9+j/wDFV41rmf8AhIdR3EE/apckDH8Zrws5/hw9T38k/iT9BdC/5GLTf+vuL/0MV1Pjz/kPQ/8AXsv/AKE1croef+Eh07aQD9qiwSM/xiuo8chxrkPmMrH7MvKrj+Jvc08m/hy9Qzv+JD0Oar1rRv8AkA2H/XtH/wCgivJa9W0dZ/7DsdskYH2aPAMZP8I/2q9w8A0aKi23H/PWL/v0f/iqNtx/z1i/79H/AOKoAlrwevc9tx/z1i/79H/4qvDK+ezr/l38/wBD6PI/+Xny/U3vBP8AyOFj/wBtP/RbUaz/AMh6/wD+vmT/ANCNJ4M3HxdZbCA37zBIyP8AVtRrGf7cvtxBP2mTJAx/Ea6cn/gP1/RHPnX+8L0/Vi6N/wAh6w/6+Y//AEIV61Xkmj5/tyx2kA/aY8EjP8Qr1bbcf89Yv+/R/wDiq9g8QloqLbcf89Yv+/R/+Ko23H/PWL/v0f8A4qgDG8bf8ifff9s//Ri15LXq3jNZh4Rvd8kZX93kBCD/AKxfevKa+Wzj+OvT9WfWZL/u79f0R3nwz/5if/bL/wBnrlK6j4bCQ/2l5bKv+qzuXP8Af9xXL17OW/7pD5/mzxc0/wB8n8vyRteEf+Rqs/8Agf8A6A1em15j4T3HxRabCA3z4JGR9xq9J23H/PWL/v0f/iq9A80loqLbcf8APWL/AL9H/wCKo23H/PWL/v0f/iqAOX+I3/Iuwf8AX2v/AKA9eaV6R8QxKPD0HmOjD7UvCoR/A/ua83r5LNf95foj7HKP91XqzsdH/wCSZ6n/ANfY/nHXP1vaQH/4VvqRDLs+1DI289Y++f6Vg19Dgf8Adoeh83j/APep+p2nw+/5iH/bL/2auzrifAIkP2/y2Vf9Xncuf73uK7Hbcf8APWL/AL9H/wCKrsOIloqLbcf89Yv+/R/+Ko23H/PWL/v0f/iqAPOfiN/yMUH/AF6L/wChvXJV1fxDDjxDB5jKx+yryq4/jf3NcpXxWO/3mfqfdYD/AHWHoeh6/wD8k/0f/dg/9FGuNrr9dEg8B6RuZSu2HAC4I/dHvmuQr7Gl/Dj6I+Jq/wASXqz0HwH/AMgGb/r5b/0Fa6auV8DCU6HN5boo+0twyE/wr7iul23H/PWL/v0f/iq0MyWiottx/wA9Yv8Av0f/AIqjbcf89Yv+/R/+KoA8q8bf8jhff9s//Ra1g1u+M9w8XXu8gt+7yQMD/VrWFXw2K/jz9X+Z99hP93p+i/I7jx5/yHof+vZf/QmrmK6XxyHGuQ+Yysfsy8quP4m9zXNV9yfAnrWjf8gGw/69o/8A0EVdrO0dZ/7DsdskYH2aPAMZP8I/2qubbj/nrF/36P8A8VQBLUV3/wAec3/XNv5VKOnPWorv/jzm/wCubfyoALT/AI84f+ua/wAqlqK0/wCPOH/rmv8AKpaAEd1jQtIwVR1LHAFebahpt5Fb3Gkf2Hpxurq6eaC7lvYluHBl37gCNxYdAc9h9K7XxHptxqmjmCz8ozJLHMsc+fLkKOG2tjscVzl54Rv9Q0u/vdQhtJddvpomjdTlbJEZdoRiM5ABJxjJNAHW6bcXtzal9SsVsptxAiWYS5HrkAflVuiuXufGEsMVzfR6asmk2l39lmuftGJMhgrOse3BUMcfeB4JxQB1FFQX17Bp1hPeXbhIYELu3sP61neGddk8QabLcz2LWMsVw8DwNJvKlTg5OBz7UAbFFFFABXmnxG/5GKD/AK9F/wDQ3r0uvNPiN/yMUH/Xov8A6G9eXmv+7P1R62Uf70vRnJV23iT/AJF3w7/16f8AskdcTXbeJP8AkXfDv/Xp/wCyR152TfxJeh6Wd/w4epzVem+Ef+RVs/8Agf8A6G1eZV6b4R/5FWz/AOB/+htX0p8ubVFFFABXi2u/8jFqX/X3L/6Ga9prxbXf+Ri1L/r7l/8AQzXhZz/Dh6nv5J/En6BoX/Ixab/19xf+hiup8ef8h6H/AK9l/wDQmrltC/5GLTf+vuL/ANDFdT48/wCQ9D/17L/6E1PJv4cvUM7/AIkPQ5ivWtG/5ANh/wBe0f8A6CK8lr1rRv8AkA2H/XtH/wCgivcPALtFFFABXg9e8V4PXz2df8u/n+h9Hkf/AC8+X6m94J/5HCx/7af+i2o1n/kPX/8A18yf+hGjwT/yOFj/ANtP/RbUaz/yHr//AK+ZP/QjXTk/8B+v6I586/3hen6sNG/5D1h/18x/+hCvWq8l0b/kPWH/AF8x/wDoQr1qvYPECiiigDB8bf8AIn33/bP/ANGLXkteteNv+RPvv+2f/oxa8lr5bOP469P1Z9Zkv+7v1/RHefDP/mJ/9sv/AGeuUrq/hn/zE/8Atl/7PXKV7OW/7pD5/mzxc0/3yfy/JG14R/5Gqz/4H/6A1em15l4R/wCRqs/+B/8AoDV6bXoHmhRRRQByXxG/5F2D/r7X/wBAevNK9L+I3/Iuwf8AX2v/AKA9eaV8lmv+8v0R9jlH+6r1Z2Oj/wDJM9T/AOvsfzjrn66DR/8Akmep/wDX2P5x1z9fQ4H/AHaHofN4/wD3qfqdp8Pv+Yh/2y/9mrs64z4ff8xD/tl/7NXZ12HEFFFFAHmnxG/5GKD/AK9F/wDQ3rkq634jf8jFB/16L/6G9clXxWO/3mfqfdYD/dYeh6Hr/wDyT/R/92D/ANFGuNrstf8A+Sf6P/uwf+ijXG19jS/hx9EfE1f4kvVnoPgP/kAzf9fLf+grXTVzPgP/AJAM3/Xy3/oK101aGYUUUUAeS+Nv+Rwvv+2f/otawa3vG3/I4X3/AGz/APRa1g18Niv48/V/mffYT/d6fovyO48ef8h6H/r2X/0Jq5iun8ef8h6H/r2X/wBCauYr7k+BPWtG/wCQDYf9e0f/AKCKu1S0b/kA2H/XtH/6CKu0AFRXf/HnN/1zb+VS1Fd/8ec3/XNv5UAFp/x5w/8AXNf5VLUVp/x5w/8AXNf5VLQAUUUUAFcLLoWr/wBj6j4dSwZobzUXmS/81PLSF5BIcjdv3jlcBcZwc4ruqKAOe1Sw1TX4zA6xabFa3yyJ5y/aEvEUZUsqspUbsHBPVRSeEdM1XTY9TGrtCfPv5pohFHtyGYnd99uDxheo7k10VFABTHiWQgsXGP7rlf5Gn0UARfZk/vS/9/W/xrzf4hoI/EMAUsf9FU/MxP8AG/rXpteafEb/AJGKD/r0X/0N68vNf92fqj1so/3pejOSrtPESBPD3h8gt81rk5Yn+BPXpXF123iT/kXfDv8A16f+yR152TfxJeh6Wd/w4epzVek+E4FfwvaMTJk7+kjAffbsDXm1em+Ef+RVs/8Agf8A6G1fSny5q/Zk/vS/9/W/xo+zJ/el/wC/rf41LRQBF9mT+9L/AN/W/wAa8a1wbfEOogZ4upRyc/xmvaq8W13/AJGLUv8Ar7l/9DNeFnP8OHqe/kn8SfoJoY3eIdOBzzdRDg4/jFdR45QR65CFLH/RlPzMT/E3rXMaF/yMWm/9fcX/AKGK6nx5/wAh6H/r2X/0JqeTfw5eoZ3/ABIehzFeraPbo2h2JJk5tozxKw/hHvXlNetaN/yAbD/r2j/9BFe4eAWPsyf3pf8Av63+NH2ZP70v/f1v8alooAi+zJ/el/7+t/jXhle8V4PXz2df8u/n+h9Hkf8Ay8+X6m74MUP4uslOcHzOhIP+rbuKNYG3XL4DPFzIOTn+I0vgn/kcLH/tp/6LajWf+Q9f/wDXzJ/6Ea6cn/gP1/RHPnX+8L0/ViaON2uWIOebmMcHH8Qr1b7Mn96X/v63+NeVaN/yHrD/AK+Y/wD0IV61XsHiEX2ZP70v/f1v8aPsyf3pf+/rf41LRQBzvjOBU8I3rAyZHl9ZGI/1i9ia8pr1rxt/yJ99/wBs/wD0YteS18tnH8den6s+syX/AHd+v6I7n4bRrJ/aW4sMeV91yv8Af9K5eur+Gf8AzE/+2X/s9cpXs5b/ALpD5/mzxc0/3yfy/JGz4TUP4otFOcHf0JB+43cV6T9mT+9L/wB/W/xrzfwj/wAjVZ/8D/8AQGr02vQPNIvsyf3pf+/rf40fZk/vS/8Af1v8alooA4/4hwrH4egKlz/pSj5nJ/gf1Neb16X8Rv8AkXYP+vtf/QHrzSvks1/3l+iPsco/3VerOv0hAfhvqT5bIugPvHHWPt0rBroNH/5Jnqf/AF9j+cdc/X0OB/3aHofN4/8A3qfqdj4BjWT7fuLDHl/dcr/e9K7H7Mn96X/v63+Ncj8Pv+Yh/wBsv/Zq7Ouw4iL7Mn96X/v63+NH2ZP70v8A39b/ABqWigDzL4hoI/EMAUsf9FU/MxP8b+tcpXW/Eb/kYoP+vRf/AEN65Kvisd/vM/U+6wH+6w9D0DXY1XwHpDAtkrD1ckf6o9q5Cuy1/wD5J/o/+7B/6KNcbX2NL+HH0R8TV/iS9Wd74GhWTQ5ixcf6Sw+VyP4V9DXS/Zk/vS/9/W/xrnvAf/IBm/6+W/8AQVrpq0MyL7Mn96X/AL+t/jR9mT+9L/39b/GpaKAPJPGahPF16ozgeX1JJ/1a9zWFW942/wCRwvv+2f8A6LWsGvhsV/Hn6v8AM++wn+70/Rfkdt45QR65CFLH/RlPzMT/ABN61zVdP48/5D0P/Xsv/oTVzFfcnwJ6to9ujaHYkmTm2jPErD+Ee9XPsyf3pf8Av63+NV9G/wCQDYf9e0f/AKCKu0AAGBiorv8A485v+ubfyqWorv8A485v+ubfyoALT/jzh/65r/KpaitP+POH/rmv8qloAKKKKACvPLq8vZfDeq+JFv7yO8tNSdYY1uGEKxpKI/LMYOxgQDkkZyevFeh1gSeELKS4mJursWdxdfbJrAOvkyS5Byfl34LANt3Yz2oA1NStI7yzMc9zPbQqQ8jQTGIlRzguOVHrgg++M1k+DJZ5tJuZXmnms3vJTYSXDl3a3yNp3N8xGd2C3O3b2xUmo+FYtTsbu0uNU1IRXVyJ3AlVgoA/1YDKR5fGduOa0dOsZbGJo5dQuL0cbfPSJdgHYeWijH1zQBcpjyrGQGDnP91C38hT6KAIvtKf3Zf+/Tf4V5v8Q3EniGAqGH+iqPmUj+N/WvTa80+I3/IxQf8AXov/AKG9eXmv+7P1R62Uf70vRnJV2niJw3h7w+AG+W1wcqR/Anr1ri67bxJ/yLvh3/r0/wDZI687Jv4kvQ9LO/4cPU5qvSfCc6p4XtFIkyN/SNiPvt3ArzavTfCP/Iq2f/A//Q2r6U+XNX7Sn92X/v03+FH2lP7sv/fpv8KlooAi+0p/dl/79N/hXjWuHd4h1EjPN1KeRj+M17VXi2u/8jFqX/X3L/6Ga8LOf4cPU9/JP4k/QTQzt8Q6cTni6iPAz/GK6jxy4k1yEqGH+jKPmUj+JvWuY0L/AJGLTf8Ar7i/9DFdT48/5D0P/Xsv/oTU8m/hy9Qzv+JD0OYr1bR7hF0OxBEnFtGOImP8I9q8pr1rRv8AkA2H/XtH/wCgivcPALH2lP7sv/fpv8KPtKf3Zf8Av03+FS0UARfaU/uy/wDfpv8ACvDK94rwevns6/5d/P8AQ+jyP/l58v1N3wYwTxdZMc4HmdASf9W3YUawd2uXxGebmQ8jH8RpfBP/ACOFj/20/wDRbUaz/wAh6/8A+vmT/wBCNdOT/wAB+v6I586/3hen6sTRzt1yxJzxcxngZ/iFerfaU/uy/wDfpv8ACvKtG/5D1h/18x/+hCvWq9g8Qi+0p/dl/wC/Tf4UfaU/uy/9+m/wqWigDnfGc6v4RvVAkyfL6xsB/rF7kV5TXrXjb/kT77/tn/6MWvJa+Wzj+OvT9WfWZL/u79f0R3Pw2kWP+0twY58r7qFv7/pXL11fwz/5if8A2y/9nrlK9nLf90h8/wA2eLmn++T+X5I2fCbBPFFoxzgb+gJP3G7CvSftKf3Zf+/Tf4V5v4R/5Gqz/wCB/wDoDV6bXoHmkX2lP7sv/fpv8KPtKf3Zf+/Tf4VLRQBx/wAQ5lk8PQBQ4/0pT8yEfwP6ivN69L+I3/Iuwf8AX2v/AKA9eaV8lmv+8v0R9jlH+6r1Z1+kOB8N9STDZN0D9046x9+lYNdBo/8AyTPU/wDr7H8465+vocD/ALtD0Pm8f/vU/U7HwDIsf2/cGOfL+6hb+96V2P2lP7sv/fpv8K5H4ff8xD/tl/7NXZ12HERfaU/uy/8Afpv8KPtKf3Zf+/Tf4VLRQB5l8Q3EniGAqGH+iqPmUj+N/WuUrrfiN/yMUH/Xov8A6G9clXxWO/3mfqfdYD/dYeh6Brsit4D0hQGyFh6oQP8AVHvXIV2Wv/8AJP8AR/8Adg/9FGuNr7Gl/Dj6I+Jq/wASXqzvfA0yx6HMGDn/AElj8qE/wr6Cul+0p/dl/wC/Tf4Vz3gP/kAzf9fLf+grXTVoZkX2lP7sv/fpv8KPtKf3Zf8Av03+FS0UAeSeM2D+Lr1hnB8vqCD/AKtexrCre8bf8jhff9s//Ra1g18Niv48/V/mffYT/d6fovyO28cuJNchKhh/oyj5lI/ib1rmq6fx5/yHof8Ar2X/ANCauYr7k+BPVtHuEXQ7EEScW0Y4iY/wj2q59pT+7L/36b/Cq+jf8gGw/wCvaP8A9BFXaAAHIzUV3/x5zf8AXNv5VLUV3/x5zf8AXNv5UAFp/wAecP8A1zX+VS1Faf8AHnD/ANc1/lUtABRRRQAUUUUAVtQ1G10u0NzfSiKIMFB2lizE4ChRksSegAJqPTdXstWSVrGVmML+XLHJG0bxtjOGRgGHHqKx/Gji3i0W8mytra6rFLcSY+WNNrrub0AZl57U3w3NFf8AinxBqVk6zWU32eOOeM5SVkRtxU9GAyBkentQB09FFMcSkjy3RR33IT/UUAPrzT4jf8jFB/16L/6G9ejbbj/nrF/36P8A8VWHrXhGHXb1Lm7upEdIxGBEoAwCT3z61w46jOvR5Ibnfl9eGHr889jyiu28Sf8AIu+Hf+vT/wBkjrQ/4VvY/wDP7cfkv+Fal94Wjv7KytprplSzj8uMogyRgDn/AL5FcmXYOrh5ydTqdmZ42jiYRVPoebV6b4R/5FWz/wCB/wDobVm/8IDaf8/k3/fIrd07Tn0zT47O3nVo484Lx5PJJ7H3r2TxC/RUW24/56xf9+j/APFUbbj/AJ6xf9+j/wDFUAS14trv/Ixal/19y/8AoZr2Tbcf89Yv+/R/+Krl7v4f2d5ez3Mt5OHmkaRgqjAJOTj868vMcNUxEIqn0PVyzFU8NOTqdTg9C/5GLTf+vuL/ANDFdT48/wCQ9D/17L/6E1adp8P7OzvYLmK8nLwyLIoZRgkHIz+VaGr+F49Zu1uLq5ZHVAgEaYGMk98+tGXYaph4SVTqGZ4qniZxdPoea161o3/IBsP+vaP/ANBFYH/CA2n/AD+Tf98iuitrWa1tIbeOZCkKKilozkgDHPNeoeUWqKi23H/PWL/v0f8A4qjbcf8APWL/AL9H/wCKoAlrwevc9tx/z1i/79H/AOKrkv8AhW9j/wA/tx+S/wCFeTmWFq4jl9n0v+h7GWYylhuf2nW36nL+Cf8AkcLH/tp/6LajWf8AkPX/AP18yf8AoRrs9L8EW2kalFe213K0sWdokUFTkEdsetFz4Itrq7muJLuUPM7OwVRgEnPFa5fh54ek4T3v/kY5liaeJrKdPa1vxZxmjf8AIesP+vmP/wBCFetVzFt4ItrW7huI7uUvC6uoZRgkHPNdFtuP+esX/fo//FV6J5pLRUW24/56xf8Afo//ABVG24/56xf9+j/8VQBjeNv+RPvv+2f/AKMWvJa9n1TS31fTZbK5nVYpcbjHHhhgg9yfSue/4VvY/wDP7cfkv+FeHmGCrYiqpw2t/me9luOo4ai4VN73/BFX4Z/8xP8A7Zf+z1ylel6F4aTw/wCf9juWfz9u7zUzjbnGMEetZ/8AwgNp/wA/k3/fIr0cHSlRoRpz3V/zPNx1aNfESqQ2dvyRz3hH/karP/gf/oDV6bXO6d4Qh0zUI7y3upGkjzgOoI5BHb61u7bj/nrF/wB+j/8AFV1nGS0VFtuP+esX/fo//FUbbj/nrF/36P8A8VQBy/xG/wCRdg/6+1/9AevNK9i1rQ/7dsktru42IkgkBiTByAR3J9aw/wDhW9j/AM/tx+S/4V4GOwNavW54bH0OX5hQw9DknuZWj/8AJM9T/wCvsfzjrn69HtvCcVroc+lR3TmCeTzGZkG4H5eh6fwjtVP/AIQG0/5/Jv8AvkV6+FpypUYwlujx8VUjVrynHZkHw+/5iH/bL/2auzrG0fw+NE877Jcl/O27vNTOMZxjBHrWptuP+esX/fo//FV0HMS0VFtuP+esX/fo/wDxVG24/wCesX/fo/8AxVAHnPxG/wCRig/69F/9DeuSr1fWvCMOu3qXN3dSI6RiMCJQBgEnvn1rO/4VvY/8/tx+S/4V83isur1a0pxtZn1GFzPD0qEYSvdeQzX/APkn+j/7sH/oo1xtenXnh5b3R7bTZbkiG2ChGVPmO1dozzjofSsz/hAbT/n8m/75FfQ004wSZ81UkpTbRN4D/wCQDN/18t/6CtdNWXpGjHRrRre1uN6M5cmRMnOAOxHpV/bcf89Yv+/R/wDiqsgloqLbcf8APWL/AL9H/wCKo23H/PWL/v0f/iqAPKvG3/I4X3/bP/0WtYNeo6p4IttX1KW9ubuVZZcbhGoCjAA759Kqf8K3sf8An9uPyX/CvmK+W4idWUlazb6n1dDNMNToxhJu6SW3kUfHn/Ieh/69l/8AQmrmK9K1fwvHrN2txdXLI6oEAjTAxknvn1qh/wAIDaf8/k3/AHyK+nPlDf0b/kA2H/XtH/6CKu1VtrWa1tIbeOZCkKKilozkgDHPNS7bj/nrF/36P/xVAEtRXf8Ax5zf9c2/lUo6c9aiu/8Ajzm/65t/KgAtP+POH/rmv8qlqK0/484f+ua/yqWgAooooAKKKKACiiigAooooAKKKKACisDxpdajp/hm6vdLvFtXt0LsfJDs3TABPA98g5HTHWqXiDWNRTxF/Z1it+ILeyF3M+npA0pyzKB++OMDYeACSSPxAOsoqrpl3FfaTaXdvM08U8KSJK4AZwQDkgAAH1GBVqgAooooAKKKZKJDC4gZUlKnYzruUHsSARke2R9aAH0VxUetaumi3MD3wkvH1r+zY7swqPKUso3BAMHAzgHPbOaS71rVrC+v9FW/aaX7TZxW97NFH5kSzlgxKqArEbGI4HUZzjkA7aisHRLu8XX9W0m9u3vFs1glinlRFkKyBsq2wBTgoccDg1vUAFFFFABRRVXUILi4tdlrfNYncC8yRqzBRyQN2VBPqQeM8dwAWqK4jT9X1bU5dNsV1KRIbua8kj1BIY/Nnt4ioQ4KlBkv128hcgDOaWy1rVtRvLHRnv2glW5vYri9hiTfKsBVVIDKVUtvUng9DjGeADtqKxvC+oXV9ptwl/IJrizu5rR5goXzdjkByBwCRjIHGc/StmgAooooAKKK5/xTq91aWpstIcJqEsLzCXaGFvEgyzkH14UZ6k+gNAHQUVxFtqms6xbTtBqj2TWOlQTkpDG3nzSRl9z7lOFGAMLjqeemFt9a1bxBBcXFnftpgtdKguhHFFG4klljL/MXB+QYAwMHk89KAO2oqlot82qaDp9/IoRrq2jmZV6KWUNj9au0AFFFFABRRXGa3r98utajHGdSt9P0qJGnl0+O3dssu8s3m5OAvZFJ+8SegoA7OiuGk17U30u78RQagTbW2p/Z0sREgjkhEoiOWK7wxyWzux0GKfc61q0djfa6t+whs9VNqLDyk8t4lmERyxXfvOS2Q2OgxQB21FFFABRRRQAUUV5+/ifU7XVmM987NHfTxyQFIhaGFFYhUlC7jKeBt3EghsqAKAPQKK4mDWtW02PRL2+v2vo9UtpZZrdoo0WJhCZlEZUBsAKV+YtnINTaZqOrQ3nhyS+1E3ia1G5mhaJEWFvK81fL2gNgYK/MWzweKAOwooooAKKKKACiuf8AGF1qVhpAvNNvVtliliDr5IdpN0qLjJ4Awx7Z6cjvS1S+1a41DXfsGpNYx6Rbo0cawxsJnKGQ7ywJ29BhSvc5oA62iuI/tnV9Yt9SvLLUDp62FhDcJCkSOssjxead5YE7ei4Ug9TmqsXiXWLzw1d+J477yY7a4RV08RIY3QFQ25iN+47iQQwxgcGgD0GiiigAqK7/AOPOb/rm38qlqK7/AOPOb/rm38qAC0/484f+ua/yqWorT/jzh/65r/KpaACiiigAooooAKKKKACiiigAooooAzNe0Rdf05rGa9urWCQFZVt/L/eD0JZWx+GKrXPhgXMiTnV9Qju/s7W0tzGYg80Zbdhh5e0YJOCoUjJ5rcooAhtLSCwsobS0jEUECCONB/CoGAKmoooAKKKKACmSo0kLokjRMykCRANyH1GQRke4Ip9FAHOR+DIFtbmCbVdQmW4n+1bmMStHPuDCRSsYwcgcHI9qmfwnaTW10tzd3c9zcyxzNesyrKrx48srtUKNuOBtxyc5ya3aKAM/TNIj02W5nNxPd3V0yma4uCu5towowqqoAHoB1J71oUUUAFFFFABWdrmjJrumNYzXVxbRMwLm3KguB/CdykFT3GOenStGigDDfwzvFq7avf8A2m0Zvs9yqwK0asoVkCiMIVOB1UnIGDR/wilpHb2a2l1d2tzZvI6XkbK0rtJ/rC+5Srbjyfl6gYxityigCppemwaTYLa2xdgCzvJIcvK7HLOx7kkkn68YHFW6KKACiiigArO1Xw/pOtK39pafbXEhjMazSQIzoDn7pIOOufrWjRQBzaeB9Pt4PJ025u9Pie1FrOlqY1Fwgzy2UOG+ZvmXafmPNT3XhO0mkc2l3d6ektstpNHasoWWJQQoO5WIIBIBUg89a3aKAI4II7W3jggQJFEgRFH8KgYAqSiigAooooAKw9S8LW2o3l1Oby8tlvY1iu4YHUJcKuRhsqSOCQSpU4rcooAwR4RsluG2XF0tk1yLptPBTyGlGCD93djcA23dtyOnanN4UtGvHc3V39kkuvtklhuXyXlyDuPy78bgG27tuR07VuUUAFFFFABRRRQAVzyeDLNfLhkvL2WwiuDcR2DsnlK5JPULvIBYkAtiuhooAwrHwnaWclv5t3d3kVpE8NrBcspWBGGCBtUE/KNuWLED607TfC9vp1xayfbLy6SxjaOziuHUrbqwAIGFBPAABYsQPrW3RQAUUUUAFFFFAGVruhjXrUW0uoXdrBkMyW4j+cqwZSS6MeCo6Y981VufCUV08zvqmoKbqFYbzY0a/alXIG75PlOCRlNvFb9FAGFe+ErS6mnaG7vLKO5hSC5gtnUJMijABypK8HGVKnFMbwdY+a6x3N3FZSzrPJYIy+S7rjBOV3AZUEgMAcdK6CigAooooAKiu/8Ajzm/65t/Kpaiu/8Ajzm/65t/KgAtP+POH/rmv8qlqK0/484f+ua/yqWgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArm/iAWHgm82AFvMgwCcAnz0710lVr/T7bVLJ7S+i82ByrMm4rkqwYcgg9QKAOLtNbFhoN1rrxtPr93dJZXEckTH7LIW2rFsXLbFBzheX69W4tf8JXq1vb3E91ab7WzuYPOunsJrUSQSZVyqSHIZGwSckYPQV0F34d0q+nuZrq0DvdRpHMQ7LvCHKnAP3h2b7w7GorvQwmgajZac0ksl3A8YF9eTTLkqRyXLEDnnHWgB+iancarJqEzJGtnFdNBasgOZAnyuxOcH5wwGPTvXManr11c+Hddg1xLZJks55BpctrLGdqsQD52/Eq4xkpjqOnSuu0XTI9G0Sz06HlbaJUz/AHiByfxOT+NVf+EV0lluFmiuLj7TA1vIbi8mlby25KguxKg4HTHQelAGedT1VNb0rTtPksninhSaaBrZ91vAFALGTzMZLcKNvrnoapaR4x1PU7mxnSzaS0vLgxmGPTrgGCPJAkM5/dt0GQAOvU4rfHhnTF1Fr6JbqKd/L3mK9mRX2DCgqrhSAB0I9fU0+28PafZXQntFuYMOziGO8mWEEkk/ug2zkknGOpzQBp0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVFd/8AHnN/1zb+VS1Fd/8AHnN/1zb+VABaf8ecP/XNf5VLUVp/x5w/9c1/lUtABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVFd/8AHnN/1zb+VS1Fd/8AHnN/1zb+VABaf8ecP/XNf5VLUVp/x5w/9c1/lUtABRRRQAUUUUAFFFFABRRRQAUUUUAFFFeS+Nv+Rwvv+2f/AKLWuPGYr6rTU7X1sduCwv1qo4XtpfuesO6RRtJIyoigszMcAAdyaSGaO4gSa3kSWKRQ6SIwZWUjIII6giuL8GNt8C6mwCnDynDKCD+6XqDwaTSbzU7+bw7p9vqLWEE2gpdzfZ7eLJYeWBtBUqo+bpjGOABwRtQq+2pKpa1zHEUvY1ZU73sdn9pgF2LUzR/aChkEO8bygOC2OuMkDPvRJcwRTxQyzRpLOSIo2cBpCBk7R3wOeK4nQNSvtZ1jThdTpHcS6PcB7mGCMSbkuFTcCynGcZ2/dyenAqp4W8620/wODcm4S5EvE0URMIFu52owQMvI65yehOOK2MD0OWVIIXllO1I1LMcZwAMmmWd3Df2MF3aP5kFxGssT4I3KwyDg8jg968/u/E1/LdWrRXN3cafqX2qIGWKBIXCxvgxBSZRgqPv9fbIrp/D8dxN8OdLjsp/s9y2lQiKXaDsfyhg4IIPPtQBv0V59L401O40WbUbLC/2fpqtdoyKR9qd9hBz2TY5wCOoyakv9V8T6XoOrXb/bFghsRLDdXy2pdZg3IVYSQVKnPI4x15oA72okuYJLiW3jmjeaEKZI1cFkDZxkdRnBx64rn9Xi12w0+2aC/vLtEd5L2W3jt1n27OBGrrs27uSDlunJrAfxFN/aly+m3SRxXw02Nb6W3RZFSVZSZG+UZPAADfKC3AxwQD0SiuF1bXNW0e08T20WoPdvp1pFcQXcsUe+NnzlGCqFP3cj5c4bnPFbOnz6jZ+Ljpd7qDX8Uth9p3SRIhjkEm0hdoHykEcNuIx1oA6GiiigAoqlrP8AyAb/AP69pP8A0E15LQB69d6hbWL2y3UnltdTCCEbSdzkEgcDjhTyeOKs1y/jaOWV/D0dvN5EjavGFlChin7qXkA8Z9M5Gex6Vkz+IdatZpNJE89zJ/a/2NbyNIBN5fkiUKA22LeeVyRjGeCcUAd9RXn+pprl1Z6YmrzXlk0etxpbyN9nMssbDKu4UMgZTkDGAe4NXtX1LW28Qz6RprX+bWxjlR7ZbXfO7lhvfziBtBTGEHUnkcCgDsqK45NQ1658Qpb3Mz2Rg0iK9nsrZI3Lzb3DIHIb5TtA4yemCOcxWWsamLbw5qZ1f7Z/bMypLZCKMRxh0LHyyo3/ACYwdzN3zzQB21Fef2mta9qWowz2dxqLoL6fz7ZLJFtxbxlwoWZo/mLFVHDE/M2AuKteGdV8R6nJpd+8V1PZXqM90ZfsywQhhlfK2MZOD8uHycZzg9ADtqK4PQNY1t7Xwvf3+qNdrq7NFPAYI0Rf3bMrLtXdnKc5JBycAcYfYaz4l1K8+2WdvdvGuovBLbH7MtvHErlGBJbzt4A3dhn+HGKAO5orhJdd1U6HLr6amUkTUTbDSvKjKACbyvLJK+ZvI+bO4cnpipZfEd/FolzK14q3C+IPsMeVTPl/aANmMcny8++OfegDtqK5nSr3UoPERstfnu1muDM1tGqwm1kRWBG0qvmAhWXO84JzjPFRSWsz/FIOuoXEa/2YH8pVj2lRLgpyhO09TznJ4IHFAHV0Vwo1LXv7M1XWl1OWVNN1OZPsSwRBXt45iGBO3du2ZwQR0HBOTW/4d1KfWH1G/wDP36e1yYrFQowUQbWcN1O5934AYoA26K57xZqt9Yf2ZbaesytfXXktLAIzIoCM+1PNITc23Hzds4BOKyZ9Q8TQ2dhbXUk1hJc6wLWO4nSB5ZLdonbLKmUDAjgj+6Mg8ggHb0VwUmp67a6dqt62tPMNK1JbZI3togJ0LJnzCFHOJMArt6d81Jqmr6p9v8VNDros00ZElgtxDEQ2YVfDlgWKlsgYwck8ngAA7AahbNqjacJP9LSFZ2j2nhCxUHOMdVPHXirNcDqGsNaeKJLyZ5Lae50a0RRFGHcPJO42qGIUNyQC3AOCQQCCkfibV4bTVraWaVJINQtrRbq8SEyWyTbQzP5X7slcnHbJG70oA7+iuQ1rUdT0kWmn22pT38l3fCFp0jtxcQDyt/l/Ntj3Nt4LAfKejHGdfw5Jq72lwmuQSxtHORbyTmLzZIsAguIiUBBJHGOAOKANiiiigAooooAKKKKACiiigAooooAKiu/+POb/AK5t/Kpaiu/+POb/AK5t/KgAtP8Ajzh/65r/ACqWorT/AI84f+ua/wAqloAKKKKACiiigAooooAKKKKACiiigAqpPpOnXMzTXNhazSt955IVZj26kVboqZRUlZoqMpRd4uxBDY2lvbvBb2sMUL53RpGFVsjByB14oisbSB4ngtYY2hi8mNkjAKR8fIMdF4HHTgVPRTSSVkJtt3ZXg0+ytpEe2s4IXRGRWjiVSqk7iAQOATyR681Fb6LpdpKJbTTbOCRXMgeKBVIYjBbIHUgkZ9DV2imIoLoOjrdPcrpViJ5GLvKLZNzMc5JOMkncefc+tXIYY7eBIbeNIoo1CJGihVVQMAADoAKfRQBXisLOBZxBawRi4cvMEjA81j1LY6k+pqtD4d0S2imjt9HsIo512SpHaookX0YAcj61o0UAVL/SdN1URjU9Ptb0R52faIVk25643A46D8qWTS7CVJllsbZ1nRUmDQqRIq/dVuOQMnAPSrVFAFOLRtMg0+Sxg060js5CS9ukCiN89cqBg9BVj7PD9p+0eTH54Ty/N2jdtznbnrjPOKkooAKKKKAEdFkjZJFDowIZWGQR6EVT/sbTP+gbaf8Afhf8Ku0UARzW8Fw0RnhjlML+ZGXUHY2CNwz0OCRn3NQzaXYXEM8VxY20sdywedHhVllYYwWBHzEbR19B6VaooAoLoWkJp7WC6XZLZu29rYW6eWzcclcYzwPypbrQ9Jv4oIr7TLO5jt12wpNbo4iHHCgjgcDp6Cr1FAEEVlawSrJBbQxusSwhkjAIjHRMj+EZOB0qG20XS7O9e8tNNs4LmTO+eKBVdsnJywGTk1dooA5G28CrDqVvcyXFo32e7Nz9oSx23kp3EhXn3ncOcH5RkDHFdBDoek2+oNfwaZZxXjMzNcJboJCW6ncBnJyc+tXqKAKyadZRR28cVnbolqcwKsSgRHBGVGPl4JHHrUUmh6TLqI1CXTLN70MGFy1uhkyOAd2M5GB+VXqKAKX9i6X/AGl/aH9m2f23OftPkL5mcYzuxnpxSPoekyXj3cmmWb3LkF5mt0LsQQRlsZOCoP4D0q9RQBTs9G0zT7iSew060tZpBh5IIFRn5zyQOeafcadZXdzBcXVnbzz25zDLJErNEfVSRkdB0qzRQBTuNPjbTby1slitGuVk+dYgQHcHLleNxycn19ap2+kXul6RY6dod3aW8NrCI2+0WjSl8AcjbIuO5PXrWxRQBnR6fc3drNbeIWsNRgk24iWyKJwc/MHdw3OCOmMVLb6NplpDHFa6daQxxS+dGkcCqqSYxvAA4bHGetXKKAK7afZvFLG9pA0c7+ZKhiBEj8fMwxyeByfQVmR+FbBtcv8AU7+C2vXuZo5YRNbqxtysap8pOeuwHIx29K26KAK1zptjeGQ3dlbzmWMRSGWJW3oDkKcjkAknHrUcOjaXb2sttb6baRW8y7ZYkgVUkHTBAGCPrV2igCkui6Ummtp66ZZrZOdzWwt18tjkHJXGOoB/CpbLT7PTYDBp1pBaQltxjgiCLn1wB14qxRQAUUUUAFFFFABRRRQAUUUUAFFFFABUV3/x5zf9c2/lUtRXf/HnN/1zb+VADUt2RFRbiUKowBhen5U7yX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/CjyX/5+ZfyX/CiigA8l/8An5l/Jf8ACjyX/wCfmX8l/wAKKKADyX/5+ZfyX/Cmvbs6MjXEpVhgjC9PyoooA//Z"></p>
   <h2 class="heading settled" data-level="4" id="word"><span class="secno">4. </span><span class="content">Formal wording</span><a class="self-link" href="#word"></a></h2>
   <p>Below, substitute the � character with a number the editor finds appropriate for the table, paragraph, section or sub-section.</p>
   <h3 class="heading settled" data-level="4.1" id="word_map_syn"><span class="secno">4.1. </span><span class="content">Modify class template <kbd>map</kbd> synopsis <a href="http://eel.is/c++draft/map.overview">[<strong>map.overview</strong>] </a></span><a class="self-link" href="#word_map_syn"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><c- c1>// [map.access], element access</c->
<c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
<c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->

</ins><c- n>mapped_type</c-><c- o>&amp;</c->         <c- nf>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
<c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c->   <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c->       <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></kbd></pre>
    <p>[...]</p>
<pre class="highlight"><kbd><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>..</c-> <c- n>args</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

</ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

</ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

</ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</ins></kbd></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.2" id="word_map_access"><span class="secno">4.2. </span><span class="content">Modify <a href="http://eel.is/c++draft/map.access">[<strong>map.access</strong>]</a></span><a class="self-link" href="#word_map_access"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><b>  <c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
</b></kbd></pre>
<pre class="highlight"><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>Equivalent</c-> <c- nl>to</c-><c- p>:</c-> <kbd><c- k>return</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>move</c-><c- p>(</c-><c- n>x</c-><c- p>)).</c-><c- n>first</c-><c- o>-></c-><c- n>second</c-><c- p>;</c->
</kbd></pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>id</c-></i> <kbd><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>is</c-> <c- n>valid</c->
<c- n>and</c-> <c- n>denotes</c-> <c- n>a</c-> <c- n>type</c-><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>Equivalent</c-> <c- nl>to</c-><c- p>:</c-> <kbd><c- k>return</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>x</c-><c- p>)).</c-><c- n>first</c-><c- o>-></c-><c- n>second</c-></kbd><c- p>;</c-></ins>
</pre>
<pre class="highlight"><kbd><b>  <c- n>mapped_type</c-><c- o>&amp;</c->       <c- nf>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
  <c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</b></kbd></pre>
<pre class="highlight"><c- p>[...]</c->
<small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>Logarithmic</c-><c- p>.</c->
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c->       <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>id</c-></i> <kbd><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>is</c-> <c- n>valid</c->
<c- n>and</c-> <c- n>denotes</c-> <c- n>a</c-> <c- n>type</c-><c- p>.</c-> </ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>expression</c-> <kbd><c- n>find</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-></kbd> <c- n>is</c-> <c- n>well</c-><c- o>-</c-><c- n>formed</c-> <c- n>and</c-> <c- n>has</c-> <c- n>well</c-><c- o>-</c-><c- n>defined</c-> <c- n>behavior</c-><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>A</c-> <c- n>reference</c-> <c- n>to</c-> <kbd><c- n>find</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-><c- o>-></c-><c- n>second</c-></kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Throws</c-></i><c- p>:</c-> <c- n>An</c-> <c- n>exception</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>out_of_range</c-></kbd> <c- k>if</c-> <kbd><c- n>find</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>==</c-> <c- n>end</c-><c- p>()</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>Logarithmic</c-><c- p>.</c->
</ins></ins></ins></ins></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.3" id="word_map_mod"><span class="secno">4.3. </span><span class="content">Modify <a href="http://eel.is/c++draft/map.modifiers">[<strong>map.modifiers</strong>]</a></span><a class="self-link" href="#word_map_mod"></a></h3>
   <blockquote>
<pre class="highlight"><kbd><b>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
</b></kbd></pre>
<pre class="highlight"><c- p>[...]</c->
<small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c->
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>id</c-></i> <kbd><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>is</c-> <c- n>valid</c-> <c- n>and</c-> <c- n>denotes</c-> <c- n>a</c-> <c- n>type</c-><c- p>.</c->
<c- n>For</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <kbd><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>const_iterator</c-><c- o>></c-></kbd> <c- n>and</c-> <kbd><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>iterator</c-><c- o>></c-></kbd>
<c- n>are</c-> <c- n>both</c-> <kbd>false</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <kbd><c- n>value_type</c-></kbd> <c- n>is</c-> <i><c- n>Cpp17EmplaceConstructible</c-></i> <c- n>into</c-> <kbd><c- n>map</c-></kbd> <c- n>from</c->
<kbd><c- n>piecewise_construct</c-><c- p>,</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)),</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...)</c-></kbd><c- p>.</c->
<c- n>The</c-> <c- n>conversion</c-> <c- n>from</c-> <kbd><c- n>k</c-></kbd> <c- n>into</c-> <kbd><c- n>key_type</c-></kbd> <c- n>constructs</c-> <c- n>an</c-> <c- n>object</c-> <kbd><c- n>u</c-></kbd><c- p>,</c-> <c- k>for</c-> <c- n>which</c->
<kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-> <c- o>==</c-> <c- n>find</c-><c- p>(</c-><c- n>u</c-><c- p>)</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>If</c-> <c- n>the</c-> <c- n>map</c-> <c- n>already</c-> <c- n>contains</c-> <c- n>an</c-> <c- n>element</c-> <c- n>whose</c-> <c- n>key</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>,</c-> <c- n>there</c-> <c- n>is</c-> <c- n>no</c-> <c- n>effect</c-><c- p>.</c->
<c- n>Otherwise</c-> <c- n>inserts</c-> <c- n>an</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>value_type</c-></kbd> <c- n>constructed</c-> <c- n>with</c-> <kbd><c- n>piecewise_construct</c-><c- p>,</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)),</c->
<c- n>forward_as_tuple</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...)</c-></kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>In</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <c- n>the</c-> <kbd><c- b>bool</c-></kbd> <c- n>component</c-> <c- n>of</c-> <c- n>the</c-> <c- n>returned</c-> <c- n>pair</c-> <c- n>is</c-> <kbd>true</kbd>
<c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>the</c-> <c- n>insertion</c-> <c- n>took</c-> <c- n>place</c-><c- p>.</c-> <c- n>The</c-> <c- n>returned</c-> <c- n>iterator</c-> <c- n>points</c-> <c- n>to</c-> <c- n>the</c-> <c- n>map</c-> <c- n>element</c->
<c- n>whose</c-> <c- n>key</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c-></ins>
</ins></pre>
<pre class="highlight"><c- p>[...]</c->
<kbd><b>
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</b></kbd></pre>
<pre class="highlight"><c- p>[...]</c->
<small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c->
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>id</c-></i> <kbd><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>is</c-> <c- n>valid</c->
<c- n>and</c-> <c- n>denotes</c-> <c- n>a</c-> <c- n>type</c-><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Mandates</c-></i><c- p>:</c-> <kbd><c- n>is_assignable_v</c-><c- o>&lt;</c-><c- n>mapped_type</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;></c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <kbd><c- n>value_type</c-></kbd> <c- n>is</c-> <i><c- n>Cpp17EmplaceConstructible</c-></i> <c- n>into</c-> <kbd><c- n>map</c-></kbd>
<c- n>from</c-> <kbd><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>),</c-> <c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></kbd><c- p>.</c->
<c- n>The</c-> <c- n>conversion</c-> <c- n>from</c-> <kbd><c- n>k</c-></kbd> <c- n>into</c-> <kbd><c- n>key_type</c-></kbd> <c- n>constructs</c-> <c- n>an</c-> <c- n>object</c-> <kbd><c- n>u</c-></kbd><c- p>,</c-> <c- k>for</c-> <c- n>which</c->
<kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-> <c- o>==</c-> <c- n>find</c-><c- p>(</c-><c- n>u</c-><c- p>)</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>If</c-> <c- n>the</c-> <c- n>map</c-> <c- n>already</c-> <c- n>contains</c-> <c- n>an</c-> <c- n>element</c-> <kbd><c- n>e</c-></kbd> <c- n>whose</c-> <c- n>key</c-> <c- n>is</c->
<c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>,</c-> <c- n>assigns</c-> <kbd><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></kbd> <c- n>to</c-> <kbd><c- n>e</c-><c- p>.</c-><c- n>second</c-></kbd><c- p>.</c-> <c- n>Otherwise</c-> <c- n>inserts</c->
<c- n>an</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>value_type</c-></kbd> <c- n>constructed</c-> <c- n>with</c-> <kbd><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>In</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <c- n>the</c-> <kbd><c- b>bool</c-></kbd> <c- n>component</c-> <c- n>of</c-> <c- n>the</c-> <c- n>returned</c-> <c- n>pair</c->
<c- n>is</c-> <kbd>true</kbd> <c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>the</c-> <c- n>insertion</c-> <c- n>took</c-> <c- n>place</c-><c- p>.</c-> <c- n>The</c-> <c- n>returned</c-> <c- n>iterator</c->
<c- n>points</c-> <c- n>to</c-> <c- n>the</c-> <c- n>map</c-> <c- n>element</c-> <c- n>whose</c-> <c- n>key</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c-></ins>
</pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.4" id="word_set_syn"><span class="secno">4.4. </span><span class="content">Modify class template <kbd>set</kbd> synopsis <a href="http://eel.is/c++draft/set.overview">[<strong>set.overview</strong>]</a></span><a class="self-link" href="#word_set_syn"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- k>const</c-> <c- n>value_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
<c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>value_type</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->

</ins><c- n>iterator</c-> <c- nf>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- k>const</c-> <c- n>value_type</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
<c- n>iterator</c-> <c- nf>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>value_type</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>iterator</c-> <c- n>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
</ins></kbd></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.5" id="word_set_mod"><span class="secno">4.5. </span><span class="content">Add paragraph <b>Modifiers</b> into <a href="http://eel.is/c++draft/set.overview">[<strong>set.overview</strong>]</a></span><a class="self-link" href="#word_set_mod"></a></h3>
   <blockquote>
<pre class="highlight"><b>�    <c- n>Erasure</c->        <c- p>[</c-><c- n>set</c-><c- p>.</c-><c- n>erasure</c-><c- p>]</c-></b>
</pre>
    <p>[...]</p>
<pre class="highlight"><ins><b>�    <c- n>Modifiers</c->      <c- p>[</c-><c- n>set</c-><c- p>.</c-><c- n>modifiers</c-><c- p>]</c-></b></ins>
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>iterator</c-> <c- n>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>x</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>id</c-></i> <kbd><c- n>Compare</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>is</c-> <c- n>valid</c->
<c- n>and</c-> <c- n>denotes</c-> <c- n>a</c-> <c- n>type</c-><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <kbd><c- n>value_type</c-></kbd> <c- n>is</c-> <i><c- n>Cpp17EmplaceConstructible</c-></i> <c- n>into</c-> <kbd><c- n>set</c-></kbd> <c- n>from</c-> <kbd><c- n>x</c-></kbd><c- p>.</c->
<c- n>The</c-> <c- n>conversion</c-> <c- n>from</c-> <kbd><c- n>x</c-></kbd> <c- n>into</c-> <kbd><c- n>key_type</c-></kbd> <c- n>constructs</c-> <c- n>an</c-> <c- n>object</c-> <kbd><c- n>u</c-></kbd><c- p>,</c-> <c- k>for</c-> <c- n>which</c->
<kbd><c- n>find</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>==</c-> <c- n>find</c-><c- p>(</c-><c- n>u</c-><c- p>)</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>Inserts</c-> <c- n>a</c-> <kbd><c- n>value_type</c-></kbd> <c- n>object</c-> <kbd><c- n>t</c-></kbd> <c- n>constructed</c-> <c- n>with</c->
<kbd><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>x</c-><c- p>)</c-></kbd> <c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>there</c-> <c- n>is</c-> <c- n>no</c-> <c- n>element</c-> <c- n>in</c-> <c- n>the</c-> <c- n>container</c-> <c- n>that</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>t</c-></kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>In</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <c- n>the</c-> <kbd><c- b>bool</c-></kbd> <c- n>component</c-> <c- n>of</c-> <c- n>the</c-> <c- n>returned</c-> <c- n>pair</c->
<c- n>is</c-> <kbd>true</kbd> <c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>the</c-> <c- n>insertion</c-> <c- n>took</c-> <c- n>place</c-><c- p>.</c-> <c- n>The</c-> <c- n>returned</c-> <c- n>iterator</c->
<c- n>points</c-> <c- n>to</c-> <c- n>the</c-> <c- n>set</c-> <c- n>element</c-> <c- n>that</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>x</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>Logarithmic</c-><c- p>.</c->
</ins></ins></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.6" id="word_tab_hash"><span class="secno">4.6. </span><span class="content">Modify <a href="http://eel.is/c++draft/tab:container.hash.req">[<strong>tab.container.hash.req</strong>]</a></span><a class="self-link" href="#word_tab_hash"></a></h3>
   <blockquote>
    <div style="text.align: center;"> Table �: <b>Unordered associative container requirements (in addition to container) [tab:container.hash.req]</b> </div>
    <table border="1" style="margin: auto;">
     <tbody>
      <tr>
       <th>Expression 
       <th>Return type 
       <th>Assertion/ note<br> pre- / post-condition 
       <th>Complexity 
      <tr>
       <td>[...] 
       <td>
       <td>
       <td>
      <tr>
       <td><kbd>b.bucket(k)</kbd> 
       <td><kbd>size_type</kbd> 
       <td> <i>Preconditions</i>: <kbd>b.bucket_-<br>count() > 0</kbd>.<br> <i>Returns</i>: The index of the<br> bucket in which elements<br> with keys equivalent to <kbd>k</kbd><br> would be found, if any such<br> element existed.<br> <i>Postconditions</i>: The return<br> value shall be in the range<br> <kbd>[0, b.bucket_count())</kbd>. 
       <td>Constant 
      <tr>
       <td>
        <ins><kbd>a_tran.bucket(ke)</kbd></ins>
       <td>
        <ins><kbd>size_type</kbd></ins>
       <td>
        <ins><i>Preconditions</i>: <kbd>a_tran.bucket-<br>count() > 0</kbd>.<br> <i>Returns</i>: The index of the<br> bucket in which elements<br> with keys equivalent to <kbd>ke</kbd><br> would be found, if any such<br> element existed.<br> <i>Postconditions</i>: The return<br> value shall be in the range<br> <kbd>[0, a_tran.bucket_count())</kbd>.</ins>
       <td>
        <ins>Constant</ins>
      <tr>
       <td>[...] 
       <td>
       <td>
       <td>
    </table>
   </blockquote>
   <h3 class="heading settled" data-level="4.7" id="word_req_hash"><span class="secno">4.7. </span><span class="content">Modify paragraph � in <a href="http://eel.is/c++draft/unord.req.general">[<strong>unord.req.general</strong>]</a></span><a class="self-link" href="#word_req_hash"></a></h3>
   <blockquote>
     [...] 
    <div>
      The member function templates <kbd>find</kbd>, <kbd>count</kbd>, <kbd>equal_range</kbd>, 
     <del>and</del>
     <kbd>contains</kbd> 
     <ins>and <kbd>bucket</kbd></ins>
      shall not participate in overload resolution unless the <i>qualified-ids</i> <kbd>Pred::is_transparent</kbd> and <kbd>Hash::is_transparent</kbd> are both valid
and denote types (�). 
    </div>
   </blockquote>
   <h3 class="heading settled" data-level="4.8" id="word_unord_map_syn"><span class="secno">4.8. </span><span class="content">Modify class template <kbd>unordered_map</kbd> synopsis <a href="http://eel.is/c++draft/unord.map.overview">[<strong>unord.map.overview</strong>]</a></span><a class="self-link" href="#word_unord_map_syn"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

</ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->

</ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

</ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
  <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</ins></kbd></pre>
    <p>[...]</p>
<pre class="highlight"><kbd><c- c1>// [unord.map.elem], element access</c->
<c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>);</c->
<c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->

</ins><c- n>mapped_type</c-><c- o>&amp;</c-> <c- nf>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>);</c->
<c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></kbd></pre>
    <p>[...]</p>
<pre class="highlight"><kbd><c- n>size_type</c-> <c- nf>bucket_size</c-><c- p>(</c-><c- n>size_type</c-> <c- n>n</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
<c- n>size_type</c-> <c- nf>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>size_type</c-> <c- n>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></kbd></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.9" id="word_unord_map_access"><span class="secno">4.9. </span><span class="content">Modify <a href="http://eel.is/c++draft/unord.map.access">[<strong>unord.map.access</strong>]</a></span><a class="self-link" href="#word_unord_map_access"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><b>  <c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->
</b></kbd></pre>
<pre class="highlight"><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>Equivalent</c-> <c- nl>to</c-><c- p>:</c-> <kbd><c- k>return</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>move</c-><c- p>(</c-><c- n>k</c-><c- p>)).</c-><c- n>first</c-><c- o>-></c-><c- n>second</c-><c- p>;</c->
</kbd></pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- k>operator</c-><c- p>[](</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>ids</c-></i> <kbd><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>and</c->
<kbd><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>are</c-> <c- n>valid</c-> <c- n>and</c-> <c- n>denote</c-> <c- n>types</c-><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>Equivalent</c-> <c- nl>to</c-><c- p>:</c-> <kbd><c- k>return</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)).</c-><c- n>first</c-><c- o>-></c-><c- n>second</c-></kbd><c- p>;</c-></ins>
</pre>
<pre class="highlight"><kbd><b>  <c- n>mapped_type</c-><c- o>&amp;</c->       <c- nf>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>);</c->
  <c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</b></kbd></pre>
<pre class="highlight"><c- p>[...]</c->
<small>�</small>    <i><c- nl>Throws</c-></i><c- p>:</c-> <c- n>An</c-> <c- n>exception</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>out_of_range</c-></kbd> <c- k>if</c-> <c- n>no</c-> <c- n>such</c-> <c- n>element</c-> <c- n>is</c-> <c- n>present</c-><c- p>.</c->
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>mapped_type</c-><c- o>&amp;</c->       <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- k>const</c-> <c- n>mapped_type</c-><c- o>&amp;</c-> <c- n>at</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>ids</c-></i> <kbd><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>and</c->
<kbd><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>are</c-> <c- n>valid</c-> <c- n>and</c-> <c- n>denote</c-> <c- n>types</c-><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>expression</c-> <kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></kbd> <c- n>is</c-> <c- n>well</c-><c- o>-</c-><c- n>formed</c-> <c- n>and</c-> <c- n>has</c-> <c- n>well</c-><c- o>-</c-><c- n>defined</c-> <c- n>behavior</c-><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>A</c-> <c- n>reference</c-> <c- n>to</c-> <kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-><c- o>-></c-><c- n>second</c-></kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Throws</c-></i><c- p>:</c-> <c- n>An</c-> <c- n>exception</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>out_of_range</c-></kbd> <c- k>if</c-> <kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-> <c- o>==</c-> <c- n>end</c-><c- p>()</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c->
</ins></ins></ins></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.10" id="word_unord_map_mod"><span class="secno">4.10. </span><span class="content">Modify <a href="http://eel.is/c++draft/unord.map.modifiers">[<strong>unord.map.modifiers</strong>]</a></span><a class="self-link" href="#word_unord_map_mod"></a></h3>
   <blockquote>
<pre class="highlight"><kbd><b>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
</b></kbd></pre>
<pre class="highlight"><c- p>[...]</c->
<small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c->
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>try_emplace</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...</c-> <c- n>args</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>ids</c-></i> <kbd><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>and</c->
<kbd><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>are</c-> <c- n>valid</c-> <c- n>and</c-> <c- n>denote</c-> <c- n>types</c-><c- p>.</c->
<c- n>For</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <kbd><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>const_iterator</c-><c- o>></c-></kbd> <c- n>and</c-> <kbd><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>K</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>iterator</c-><c- o>></c-></kbd>
<c- n>are</c-> <c- n>both</c-> <kbd>false</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <kbd><c- n>value_type</c-></kbd> <c- n>is</c-> <i><c- n>Cpp17EmplaceConstructible</c-></i> <c- n>into</c-> <kbd><c- n>unordered_map</c-></kbd> <c- n>from</c->
<kbd><c- n>piecewise_construct</c-><c- p>,</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)),</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...)</c-></kbd><c- p>.</c->
<c- n>The</c-> <c- n>conversion</c-> <c- n>from</c-> <kbd><c- n>k</c-></kbd> <c- n>into</c-> <kbd><c- n>key_type</c-></kbd> <c- n>constructs</c-> <c- n>an</c-> <c- n>object</c-> <kbd><c- n>u</c-></kbd><c- p>,</c-> <c- k>for</c-> <c- n>which</c->
<kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-> <c- o>==</c-> <c- n>find</c-><c- p>(</c-><c- n>u</c-><c- p>)</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>If</c-> <c- n>the</c-> <c- n>map</c-> <c- n>already</c-> <c- n>contains</c-> <c- n>an</c-> <c- n>element</c-> <c- n>whose</c-> <c- n>key</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>,</c->
<c- n>there</c-> <c- n>is</c-> <c- n>no</c-> <c- n>effect</c-><c- p>.</c-> <c- n>Otherwise</c-> <c- n>inserts</c-> <c- n>an</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>value_type</c-></kbd> <c- n>constructed</c-> <c- n>with</c->
<kbd><c- n>piecewise_construct</c-><c- p>,</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>)),</c-> <c- n>forward_as_tuple</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...)</c-></kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>In</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <c- n>the</c-> <kbd><c- b>bool</c-></kbd> <c- n>component</c-> <c- n>of</c-> <c- n>the</c-> <c- n>returned</c-> <c- n>pair</c-> <c- n>is</c-> <kbd>true</kbd>
<c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>the</c-> <c- n>insertion</c-> <c- n>took</c-> <c- n>place</c-><c- p>.</c-> <c- n>The</c-> <c- n>returned</c-> <c- n>iterator</c-> <c- n>points</c-> <c- n>to</c-> <c- n>the</c-> <c- n>map</c-> <c- n>element</c->
<c- n>whose</c-> <c- n>key</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c-></ins>
</ins></pre>
<pre class="highlight"><c- p>[...]</c->
<kbd><b>
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>key_type</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</b></kbd></pre>
<pre class="highlight"><c- p>[...]</c->
<small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c->
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- p>,</c-> <c- k>class</c-> <c- nc>M</c-><c- o>></c->
    <c- n>iterator</c-> <c- n>insert_or_assign</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>k</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>ids</c-></i> <kbd><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>and</c->
<kbd><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>are</c-> <c- n>valid</c-> <c- n>and</c-> <c- n>denote</c-> <c- n>types</c-><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Mandates</c-></i><c- p>:</c-> <kbd><c- n>is_assignable_v</c-><c- o>&lt;</c-><c- n>mapped_type</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>M</c-><c- o>&amp;&amp;></c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <kbd><c- n>value_type</c-></kbd> <c- n>is</c-> <i><c- n>Cpp17EmplaceConstructible</c-></i> <c- n>into</c-> <kbd><c- n>unordered_map</c-></kbd>
<c- n>from</c-> <kbd><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>),</c-> <c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></kbd><c- p>.</c->
<c- n>The</c-> <c- n>conversion</c-> <c- n>from</c-> <kbd><c- n>k</c-></kbd> <c- n>into</c-> <kbd><c- n>key_type</c-></kbd> <c- n>constructs</c-> <c- n>an</c-> <c- n>object</c-> <kbd><c- n>u</c-></kbd><c- p>,</c-> <c- k>for</c-> <c- n>which</c->
<kbd><c- n>find</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-> <c- o>==</c-> <c- n>find</c-><c- p>(</c-><c- n>u</c-><c- p>)</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>If</c-> <c- n>the</c-> <c- n>map</c-> <c- n>already</c-> <c- n>contains</c-> <c- n>an</c-> <c- n>element</c-> <kbd><c- n>e</c-></kbd> <c- n>whose</c-> <c- n>key</c-> <c- n>is</c->
<c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>,</c-> <c- n>assigns</c-> <kbd><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></kbd> <c- n>to</c-> <kbd><c- n>e</c-><c- p>.</c-><c- n>second</c-></kbd><c- p>.</c-> <c- n>Otherwise</c-> <c- n>inserts</c->
<c- n>an</c-> <c- n>object</c-> <c- n>of</c-> <c- n>type</c-> <kbd><c- n>value_type</c-></kbd> <c- n>constructed</c-> <c- n>with</c-> <kbd><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>k</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>M</c-><c- o>></c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>In</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <c- n>the</c-> <kbd><c- b>bool</c-></kbd> <c- n>component</c-> <c- n>of</c-> <c- n>the</c-> <c- n>returned</c-> <c- n>pair</c->
<c- n>is</c-> <kbd>true</kbd> <c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>the</c-> <c- n>insertion</c-> <c- n>took</c-> <c- n>place</c-><c- p>.</c-> <c- n>The</c-> <c- n>returned</c-> <c- n>iterator</c->
<c- n>points</c-> <c- n>to</c-> <c- n>the</c-> <c- n>map</c-> <c- n>element</c-> <c- n>whose</c-> <c- n>key</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>k</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>The</c-> <c- n>same</c-> <c- n>as</c-> <kbd><c- n>emplace</c-></kbd> <c- n>and</c-> <kbd><c- n>emplace_hint</c-></kbd><c- p>,</c-> <c- n>respectively</c-><c- p>.</c-></ins>
</ins></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.11" id="word_unord_multimap_syn"><span class="secno">4.11. </span><span class="content">Modify class template <kbd>unordered_multimap</kbd> synopsis <a href="http://eel.is/c++draft/unord.multimap.overview">[<strong>unord.multimap.overview</strong>]</a></span><a class="self-link" href="#word_unord_multimap_syn"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><c- n>size_type</c-> <c- nf>bucket_size</c-><c- p>(</c-><c- n>size_type</c-> <c- n>n</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
<c- n>size_type</c-> <c- nf>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>size_type</c-> <c- n>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></kbd></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.12" id="word_unord_set_syn"><span class="secno">4.12. </span><span class="content">Modify class template <kbd>unordered_set</kbd> synopsis <a href="http://eel.is/c++draft/unord.set.overview">[<strong>unord.set.overview</strong>]</a></span><a class="self-link" href="#word_unord_set_syn"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- k>const</c-> <c- n>value_type</c-><c- o>&amp;</c-> <c- n>obj</c-><c- p>);</c->
<c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>value_type</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

</ins><c- n>iterator</c-> <c- nf>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- k>const</c-> <c- n>value_type</c-><c- o>&amp;</c-> <c- n>obj</c-><c- p>);</c->
<c- n>iterator</c-> <c- nf>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>value_type</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>iterator</c-> <c- n>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</ins></kbd></pre>
    <p>[...]</p>
<pre class="highlight"><kbd><c- n>size_type</c-> <c- nf>bucket_size</c-><c- p>(</c-><c- n>size_type</c-> <c- n>n</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
<c- n>size_type</c-> <c- nf>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>size_type</c-> <c- n>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></kbd></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.13" id="word_unord_set_mod"><span class="secno">4.13. </span><span class="content">Add paragraph <b>Modifiers</b> into <a href="http://eel.is/c++draft/unord.set.overview">[<strong>unord.set.overview</strong>]</a></span><a class="self-link" href="#word_unord_set_mod"></a></h3>
   <blockquote>
<pre class="highlight"><b>�    <c- n>Erasure</c->        <c- p>[</c-><c- n>unord</c-><c- p>.</c-><c- n>set</c-><c- p>.</c-><c- n>erasure</c-><c- p>]</c-></b>
</pre>
    <p>[...]</p>
<pre class="highlight"><ins><b>�    <c- n>Modifiers</c->      <c- p>[</c-><c- n>unord</c-><c- p>.</c-><c- n>set</c-><c- p>.</c-><c- n>modifiers</c-><c- p>]</c-></b></ins>
</pre>
<pre class="highlight"><kbd><b><ins>  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>pair</c-><c- o>&lt;</c-><c- n>iterator</c-><c- p>,</c-> <c- b>bool</c-><c- o>></c-> <c- n>insert</c-><c- p>(</c-><c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>iterator</c-> <c- n>insert</c-><c- p>(</c-><c- n>const_iterator</c-> <c- n>hint</c-><c- p>,</c-> <c- n>K</c-><c- o>&amp;&amp;</c-> <c- n>obj</c-><c- p>);</c->
</ins></b></kbd></pre>
<pre class="highlight"><ins><small>�</small>    <i><c- nl>Constraints</c-></i><c- p>:</c-> <i><c- n>Qualified</c-><c- o>-</c-><c- n>ids</c-></i> <kbd><c- n>Hash</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>and</c->
<kbd><c- n>Pred</c-><c- o>::</c-><c- n>is_transparent</c-></kbd> <c- n>are</c-> <c- n>valid</c-> <c- n>and</c-> <c- n>denote</c-> <c- n>types</c-><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Preconditions</c-></i><c- p>:</c-> <kbd><c- n>value_type</c-></kbd> <c- n>is</c-> <i><c- n>Cpp17EmplaceConstructible</c-></i> <c- n>into</c-> <kbd><c- n>unordered_set</c-></kbd> <c- n>from</c-> <kbd><c- n>x</c-></kbd><c- p>.</c->
<c- n>The</c-> <c- n>conversion</c-> <c- n>from</c-> <kbd><c- n>obj</c-></kbd> <c- n>into</c-> <kbd><c- n>key_type</c-></kbd> <c- n>constructs</c-> <c- n>an</c-> <c- n>object</c-> <kbd><c- n>u</c-></kbd><c- p>,</c-> <c- k>for</c-> <c- n>which</c->
<kbd><c- n>find</c-><c- p>(</c-><c- n>obj</c-><c- p>)</c-> <c- o>==</c-> <c- n>find</c-><c- p>(</c-><c- n>u</c-><c- p>)</c-></kbd> <c- n>is</c-> <kbd>true</kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Effects</c-></i><c- p>:</c-> <c- n>Inserts</c-> <c- n>a</c-> <kbd><c- n>value_type</c-></kbd> <c- n>object</c-> <kbd><c- n>t</c-></kbd> <c- n>constructed</c-> <c- n>with</c->
<kbd><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>K</c-><c- o>></c-><c- p>(</c-><c- n>x</c-><c- p>)</c-></kbd> <c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>there</c-> <c- n>is</c-> <c- n>no</c-> <c- n>element</c-> <c- n>in</c-> <c- n>the</c-> <c- n>container</c-> <c- n>that</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>t</c-></kbd><c- p>.</c->
<ins><small>�</small>    <i><c- nl>Returns</c-></i><c- p>:</c-> <c- n>In</c-> <c- n>the</c-> <c- n>first</c-> <c- n>overload</c-><c- p>,</c-> <c- n>the</c-> <kbd><c- b>bool</c-></kbd> <c- n>component</c-> <c- n>of</c-> <c- n>the</c-> <c- n>returned</c-> <c- n>pair</c->
<c- n>is</c-> <kbd>true</kbd> <c- k>if</c-> <c- n>and</c-> <c- n>only</c-> <c- k>if</c-> <c- n>the</c-> <c- n>insertion</c-> <c- n>took</c-> <c- n>place</c-><c- p>.</c-> <c- n>The</c-> <c- n>returned</c-> <c- n>iterator</c->
<c- n>points</c-> <c- n>to</c-> <c- n>the</c-> <c- n>set</c-> <c- n>element</c-> <c- n>that</c-> <c- n>is</c-> <c- n>equivalent</c-> <c- n>to</c-> <kbd><c- n>x</c-></kbd><c- p>.</c-></ins>
<ins><small>�</small>    <i><c- nl>Complexity</c-></i><c- p>:</c-> <c- n>Average</c-> <c- k>case</c-> <c- o>-</c-> <c- n>constant</c-><c- p>,</c-> <c- n>worst</c-> <c- k>case</c-> <c- o>-</c-> <c- n>linear</c-><c- p>.</c->
</ins></ins></ins></pre>
   </blockquote>
   <h3 class="heading settled" data-level="4.14" id="word_unord_multiset_syn"><span class="secno">4.14. </span><span class="content">Modify class template <kbd>unordered_multiset</kbd> synopsis <a href="http://eel.is/c++draft/unord.multiset.overview">[<strong>unord.multiset.overview</strong>]</a></span><a class="self-link" href="#word_unord_multiset_syn"></a></h3>
   <blockquote>
     [...] 
<pre class="highlight"><kbd><c- n>size_type</c-> <c- nf>bucket_size</c-><c- p>(</c-><c- n>size_type</c-> <c- n>n</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
<c- n>size_type</c-> <c- nf>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>key_type</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>K</c-><c- o>></c-> <c- n>size_type</c-> <c- n>bucket</c-><c- p>(</c-><c- k>const</c-> <c- n>K</c-><c- o>&amp;</c-> <c- n>k</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</ins></kbd></pre>
   </blockquote>
   <h2 class="heading settled" data-level="5" id="history"><span class="secno">5. </span><span class="content">Revision history</span><a class="self-link" href="#history"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="r2#r3"><span class="secno">5.1. </span><span class="content">R2 ➡ R3</span><a class="self-link" href="#r2%23r3"></a></h3>
   <ul>
    <li data-md>
     <p>Added Preconditions for <code class="highlight"><c- n>at</c-></code> method in <a href="#word">§ 4 Formal wording</a>.</p>
    <li data-md>
     <p>Added <a href="#dec_at">§ 3.7.5 at method design rationale</a>.</p>
   </ul>
   <h3 class="heading settled" data-level="5.2" id="r1#r2"><span class="secno">5.2. </span><span class="content">R1 ➡ R2</span><a class="self-link" href="#r1%23r2"></a></h3>
   <ul>
    <li data-md>
     <p>Extended <a href="#decisions">§ 3.7 Design decisions</a> to apply the feedback from LEWG.</p>
    <li data-md>
     <p>Added <a href="#perf">§ 3.9 Performance evaluation</a>.</p>
    <li data-md>
     <p>Updated <a href="#word">§ 4 Formal wording</a> with the precondition about convertion and comparison consistency.</p>
   </ul>
   <h3 class="heading settled" data-level="5.3" id="r0r1"><span class="secno">5.3. </span><span class="content">R0 ➡ R1</span><a class="self-link" href="#r0r1"></a></h3>
   <ul>
    <li data-md>
     <p>Removed <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_constructible_v</c-></code> constraint. For more information see <a href="#decisions">§ 3.7 Design decisions</a>.</p>
    <li data-md>
     <p>Added <a href="#word">§ 4 Formal wording</a>.</p>
   </ul>
   <h2 class="heading settled" data-level="6" id="acknow"><span class="secno">6. </span><span class="content">Acknowledgments</span><a class="self-link" href="#acknow"></a></h2>
   <p>Special thanks to Tim Song for many findings during the paper review that eventually improved the
quality of the proposal.</p>
  </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-n3657">[N3657]
   <dd>J. Wakely, S. Lavavej, J. Muñoz. <a href="https://wg21.link/n3657"><cite>Adding heterogeneous comparison lookup to associative containers (rev 4)</cite></a>. 19 March 2013. URL: <a href="https://wg21.link/n3657">https://wg21.link/n3657</a>
   <dt id="biblio-p0919r0">[P0919R0]
   <dd>Mateusz Pusz. <a href="https://wg21.link/p0919r0"><cite>Heterogeneous lookup for unordered containers</cite></a>. 8 February 2018. URL: <a href="https://wg21.link/p0919r0">https://wg21.link/p0919r0</a>
   <dt id="biblio-p2077r2">[P2077R2]
   <dd>Konstantin Boyarinov, Sergey Vinogradov; Ruslan Arutyunyan. <a href="https://wg21.link/p2077r2"><cite>Heterogeneous erasure overloads for associative containers</cite></a>. 15 December 2020. URL: <a href="https://wg21.link/p2077r2">https://wg21.link/p2077r2</a>
  </dl>