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

/* color variables included separately for reliability */

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

	html {
	}

	body {
		counter-reset: example figure issue;

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	p {
		margin: 1em 0;
	}

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

	/* Do something nice. */

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

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

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

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

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

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

	img {
		border-style: none;
	}

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/*
Alternate table alignment rules

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

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

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

Possible extra rowspan handling

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

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

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


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

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

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

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

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

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

		.toc li {
			clear: both;
		}

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.outdated-warning span {
	display: block;
}

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

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

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

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

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



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

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

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

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

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

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

@media (prefers-color-scheme: dark) {
table, th, td {
    border-color: rgba(255, 255, 255, 0.5);
}
}

.indent {
    padding-left: 2em;
}

svg {
    background: none;
    vertical-align: middle;
}

ins {
    background: rgba(136, 255, 93, 0.2);
    color: inherit;
}
ins::not(.ins-block) {
    text-decoration: underlined;
}

.ins-block, .ins-block * {
    text-decoration: none !important;
}
.ins-block {
    background: rgba(136, 255, 93, 0.2) !important;
}

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

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

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

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

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

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

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

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

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

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

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

    --heading-text: #005a9c;

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

    --algo-border: #def;

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

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

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

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

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

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

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

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

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

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

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

    --datacell-border: silver;

    --indexinfo-text: #707070;

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

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

    --editedrec-bg: darkorange;
}

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

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

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

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

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

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

        --heading-text: #8af;

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

        --algo-border: #456;

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

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

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

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

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

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

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

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

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

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

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

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

        --datacell-border: silver;

        --indexinfo-text: #aaa;

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

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

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

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

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

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

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

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

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P3568R1<br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code></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="2025-03-13">2025-03-13</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://eisenwave.github.io/cpp-proposals/break-continue-label.html">https://eisenwave.github.io/cpp-proposals/break-continue-label.html</a>
     <dt class="editor">Author:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:janschultke@gmail.com">Jan Schultke</a>
     <dt>Audience:
     <dd>SG22, EWG
     <dt>Project:
     <dd>ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
     <dt>Source:
     <dd><a href="https://github.com/Eisenwave/cpp-proposals/blob/master/src/break-continue-label.bs">eisenwave/cpp-proposals</a>
    </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>Introduce <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> to <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> out of nested loops and <code class="highlight"><c- k>switch</c-></code>es as accepted into C2y,
and relax label restrictions.</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="#history"><span class="secno">1</span> <span class="content">Revision history</span></a>
     <ol class="toc">
      <li><a href="#history-since-r0"><span class="secno">1.1</span> <span class="content">Since R0</span></a>
     </ol>
    <li><a href="#introduction"><span class="secno">2</span> <span class="content">Introduction</span></a>
    <li>
     <a href="#motivation"><span class="secno">3</span> <span class="content">Motivation</span></a>
     <ol class="toc">
      <li>
       <a href="#no-good-alternatives"><span class="secno">3.1</span> <span class="content">No good alternative</span></a>
       <ol class="toc">
        <li><a href="#alternative-goto"><span class="secno">3.1.1</span> <span class="content"><code class="highlight"><c- k>goto</c-></code></span></a>
        <li><a href="#alternative-iile"><span class="secno">3.1.2</span> <span class="content">Immediately invoked lambda expression (IILE)</span></a>
        <li><a href="#alternative-bool-state"><span class="secno">3.1.3</span> <span class="content">Mutable <code class="highlight"><c- b>bool</c-></code> state</span></a>
       </ol>
      <li><a href="#constant-expressions"><span class="secno">3.2</span> <span class="content">Constant expressions</span></a>
      <li>
       <a href="#argumentum-ad-populum"><span class="secno">3.3</span> <span class="content">Argumentum ad populum</span></a>
       <ol class="toc">
        <li><a href="#poll"><span class="secno">3.3.1</span> <span class="content">Poll</span></a>
        <li><a href="#how-common-is-break-continue-label"><span class="secno">3.3.2</span> <span class="content">How common is <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> with labels?</span></a>
       </ol>
      <li><a href="#c2y-compatibility"><span class="secno">3.4</span> <span class="content">C2y compatibility</span></a>
     </ol>
    <li>
     <a href="#design-considerations"><span class="secno">4</span> <span class="content">Design Considerations</span></a>
     <ol class="toc">
      <li><a href="#alternative-break-continue-forms"><span class="secno">4.1</span> <span class="content">Alternative <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> forms</span></a>
      <li>
       <a href="#changes-to-labels"><span class="secno">4.2</span> <span class="content">Changes to labels</span></a>
       <ol class="toc">
        <li><a href="#design-philosophy"><span class="secno">4.2.1</span> <span class="content">Design philosophy</span></a>
        <li><a href="#new-labels-duplicates"><span class="secno">4.2.2</span> <span class="content">Allowing duplicate labels</span></a>
        <li><a href="#new-labels-nesting"><span class="secno">4.2.3</span> <span class="content">Reusing labels in nested loops</span></a>
        <li><a href="#new-labels-duplicates-on-same-statement"><span class="secno">4.2.4</span> <span class="content">Duplicate labels on the <em>same</em> statement</span></a>
        <li><a href="#new-labels-break-label-multiple"><span class="secno">4.2.5</span> <span class="content"><code class="highlight"><c- k>break</c-> <c- n>label</c-></code> for loops with more than one label</span></a>
       </ol>
     </ol>
    <li><a href="#impact-on-existing-code"><span class="secno">5</span> <span class="content">Impact on existing code</span></a>
    <li><a href="#implementation-experience"><span class="secno">6</span> <span class="content">Implementation experience</span></a>
    <li><a href="#proposed-wording"><span class="secno">7</span> <span class="content">Proposed wording</span></a>
    <li><a href="#acknowledgements"><span class="secno">8</span> <span class="content">Acknowledgements</span></a>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#normative"><span class="secno"></span> <span class="content">Normative References</span></a>
      <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="history"><span class="secno">1. </span><span class="content">Revision history</span><a class="self-link" href="#history"></a></h2>
   <h3 class="heading settled" data-level="1.1" id="history-since-r0"><span class="secno">1.1. </span><span class="content">Since R0</span><a class="self-link" href="#history-since-r0"></a></h3>
   <p>The paper was seen by EWGI and then by EWG at Hagenberg 2025,
with the following polls:</p>
   <blockquote>
    <p><b>P3568R0</b>: EWG likes syntax <code class="highlight"><c- nl>N3355</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-> <c- p>{</c-> <c- p>}</c-></code></p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>4
       <td>16
       <td>5
       <td>9
       <td>5
    </table>
    <p><b>P3568R0</b>: EWG likes syntax <code class="highlight"><c- k>for</c-> <c- n>N3377</c-> <c- p>(...)</c-> <c- p>{</c-> <c- p>}</c-></code></p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>7
       <td>13
       <td>5
       <td>5
       <td>8
    </table>
    <p><b>P3568R0</b>: If C has it, we are interested in this feature too.</p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>16
       <td>21
       <td>5
       <td>2
       <td>1
    </table>
   </blockquote>
   <p>Due to lack of consensus in EWG,
syntactical design choices were delegated to WG14.
WG14 saw <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> at Graz 2025 and voted as follows:</p>
   <blockquote>
    <p><b>N3377</b>: Would WG14 like to see a paper changing loop name syntax at a future meeting?</p>
    <table>
     <tbody>
      <tr>
       <td>F
       <td>N
       <td>A
      <tr>
       <td>6
       <td>11
       <td>9
    </table>
   </blockquote>
   <p>The authors of <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> have expressed that they are no longer pursuing the paper;
therefore, R1 of this paper assumes that the debate on label syntax is entirely settled,
and C++ follows the <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax.</p>
   <p>Furthermore, the proposed wording has been improved slightly,
and a <code class="highlight"><c- n>__cpp_break_label</c-></code> feature-test macro is now included.</p>
   <h2 class="heading settled" data-level="2" id="introduction"><span class="secno">2. </span><span class="content">Introduction</span><a class="self-link" href="#introduction"></a></h2>
   <p>While C++ already has a broad selection of control flow constructs,
one construct commonly found in other languages is notably absent:
the ability to apply <code class="highlight"><c- k>break</c-></code> or <code class="highlight"><c- k>continue</c-></code> to a loop or <code class="highlight"><c- k>switch</c-></code> when
this isn’t the innermost enclosing statement.
This feature is popular, simple, and quite useful:</p>
   <p>Specifically, we propose the following functionality:</p>
<pre class="language-cpp highlight"><c- nl>outer</c-><c- p>:</c-> <c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>x</c-> <c- o>:</c-> <c- n>xs</c-><c- p>)</c-> <c- p>{</c->
    <c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>y</c-> <c- o>:</c-> <c- n>ys</c-><c- p>)</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
            <c- k>continue</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// OK, continue applies to outer for loop</c->
            <c- k>break</c-> <c- n>outer</c-><c- p>;</c->    <c- c1>// OK, break applies to outer for loop  </c->
        <c- p>}</c->
    <c- p>}</c->
<c- p>}</c->

<c- nl>switch_label</c-><c- p>:</c-> <c- k>switch</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- k>default</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- d>/* ...*/</c-><c- p>)</c-> <c- p>{</c->
            <c- k>break</c-> <c- n>switch_label</c-><c- p>;</c-> <c- c1>// OK, break applies to switch, not to while loop</c->
        <c- p>}</c->
    <c- p>}</c->
<c- p>}</c->

<c- k>break</c-> <c- n>outer</c-><c- p>;</c->       <c- c1>// error: cannot break loop from the outside</c->
<c- k>goto</c-> <c- n>outer</c-><c- p>;</c->        <c- c1>// OK, used to be OK, and is unaffected by this proposal</c->

<c- nl>switch_label</c-><c- p>:;</c->     <c- c1>// OK, labels can be reused</c->
<c- k>goto</c-> <c- n>switch_label</c-><c- p>;</c-> <c- c1>// error: jump target is ambiguous</c->
</pre>
   <p>The <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> syntax is identical to that in <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> and has been accepted into C2y (see working draft at <a data-link-type="biblio" href="#biblio-n3435" title="ISO/IEC 9899:202y (en) — n3435 working draft">[N3435]</a>).
We bring that syntax into C++ and relax restrictions on labels to
make it more powerful,
and to address concerns in a follow-up proposal <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>.</p>
   <p>Note that <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> with labels have been proposed in <a data-link-type="biblio" href="#biblio-n3879" title="Explicit Flow Control: break label, goto case and explicit switch">[N3879]</a> and rejected at Rapperswil 2014 (<a data-link-type="biblio" href="#biblio-n4327" title="C++ Standard Evolution Closed Issues List (Revision R10)">[N4327]</a>):</p>
   <blockquote>
    <p>Straw poll, proposal as a whole:</p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>1
       <td>1
       <td>1
       <td>13
       <td>10
    </table>
    <p>"break label;" + "continue label;"</p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>3
       <td>8
       <td>4
       <td>9
       <td>3
    </table>
   </blockquote>
   <p>I believe that rejecting <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> was a grave mistake at a time.
Regardless, the WG21 sentiment towards the feature is now the opposite,
even if just for C compatibility (see <a href="#history-since-r0">§ 1.1 Since R0</a>).</p>
   <h2 class="heading settled" data-level="3" id="motivation"><span class="secno">3. </span><span class="content">Motivation</span><a class="self-link" href="#motivation"></a></h2>
   <p><code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> are largely motivated by the ability to control nested loops.
This is a highly popular feature in other languages,
and C++ could use it too, since it has no good alternative.</p>
   <p>To be fair, a conditional <code class="highlight"><c- k>return</c-></code> in the loop sometimes bypasses the need to terminate it.
However, this is not always allowed; such practice is outlawed by
MISRA-C++:2008 Rule 6-6-5 "A function shall have a single point of exit at the end of the function"
(<a data-link-type="biblio" href="#biblio-misra-c" title="MISRA C++:2023">[MISRA-C++]</a>).
Even if it is permitted, there are many cases where an early <code class="highlight"><c- k>return</c-></code> does not obsolete <code class="highlight"><c- k>break</c-></code>, and it generally does not obsolete <code class="highlight"><c- k>continue</c-></code>.</p>
   <p class="note" role="note"><span class="marker">Note:</span> I have been told that more recent revisions of MISRA-C++ no longer include this rule.</p>
   <h3 class="heading settled" data-level="3.1" id="no-good-alternatives"><span class="secno">3.1. </span><span class="content">No good alternative</span><a class="self-link" href="#no-good-alternatives"></a></h3>
   <p>Let’s examine a motivating example which uses our new construct:</p>
   <div class="example" id="example-d03f000b">
    <a class="self-link" href="#example-d03f000b"></a> 
<pre class="language-cpp highlight"><c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- nl>process_files</c-><c- p>:</c-> <c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
        <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
            <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
                <c- k>continue</c-> <c- n>process_files</c-><c- p>;</c->
            <c- p>}</c->
            <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
        <c- p>}</c->
        <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- p>}</c->
    <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
<c- p>}</c->
</pre>
    <p><code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> is very useful in this scenario,
and expresses our intent with unparalleled clarity.
We want to continue processing other files, so we <code class="highlight"><c- k>continue</c-> <c- n>process_files</c-></code>.</p>
    <p>A plain <code class="highlight"><c- k>break</c-></code> cannot be used here because it would result in executing the
following <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>println</c-></code> statement, but this should only be done upon success.</p>
   </div>
   <p>There are alternative ways to write this, but all of them have various issues.</p>
   <h4 class="heading settled" data-level="3.1.1" id="alternative-goto"><span class="secno">3.1.1. </span><span class="content"><code class="highlight"><c- k>goto</c-></code></span><a class="self-link" href="#alternative-goto"></a></h4>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
    <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
            <c- k>goto</c-> <c- n>done_with_file</c-><c- p>;</c->
        <c- p>}</c->
        <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
    <c- p>}</c->
    <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- nl>done_with_file</c-><c- p>:</c->
<c- p>}</c->
<c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
</pre>
   <p><code class="highlight"><c- k>goto</c-></code> is similar in complexity and even readability here, however there are some issues:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- k>goto</c-></code> cannot cross (non-vacuous) initialization,
which would be an issue if some variable was initialized prior to <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>println</c-></code>.
This can be addressed by surrounding the outer loop contents with another set of braces,
but this solution isn’t obvious and takes away from the elegance of <code class="highlight"><c- k>goto</c-></code> here.</p>
    <li data-md>
     <p><code class="highlight"><c- k>goto</c-></code> cannot be used in constant expressions.
For processing text files like in the example, this doesn’t matter,
but nested loops are desirable in a <code class="highlight"><c- k>constexpr</c-></code> context as well.</p>
    <li data-md>
     <p>Many style guides ban or discourage the use of <code class="highlight"><c- k>goto</c-></code>.
See <a data-link-type="biblio" href="#biblio-misra-c" title="MISRA C++:2023">[MISRA-C++]</a>, <a data-link-type="biblio" href="#biblio-cppcoreguidelineses76" title="CppCoreGuidelines/ES.76: Avoid goto">[CppCoreGuidelinesES76]</a>, etc.
This discouragement dates all the way back to 1968 (see <a data-link-type="biblio" href="#biblio-gotoconsideredharmful" title="Go To Statement Considered Harmful">[GotoConsideredHarmful]</a>),
and 66 years of teaching not to use <code class="highlight"><c- k>goto</c-></code> won’t be undone.</p>
    <li data-md>
     <p>Even in the cases where <code class="highlight"><c- k>goto</c-></code> isn’t discouraged,
those cases are always special, like "only <code class="highlight"><c- k>goto</c-></code> forwards",
"only <code class="highlight"><c- k>goto</c-></code> to break out of loops", etc..
This issue has been debated for decades,
and there is still no consensus on when, actually, <code class="highlight"><c- k>goto</c-></code> is okay to use.</p>
    <li data-md>
     <p><code class="highlight"><c- k>goto</c-></code> is innately more difficult to use because to understand its purpose,
the user has to know where the jump target is located.
A <code class="highlight"><c- k>goto</c-> <c- n>past_the_loop</c-></code> behaves radically differently compared to a <code class="highlight"><c- k>goto</c-> <c- n>before_the_loop</c-></code>.
Moving the jump target or the <code class="highlight"><c- k>goto</c-></code> statement relative to each other can also completely
change these semantics.
By comparison, <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> always jump forwards,
past a surrounding loop, or to the end of a surrounding loop respectively.
This makes them much easier to reason about, and much less error-prone.</p>
    <li data-md>
     <p>The "local readability" of <code class="highlight"><c- k>goto</c-></code> relies heavily on high-quality naming for the label.
A <code class="highlight"><c- k>goto</c-> <c- n>end</c-></code> could mean to the end of a loop, to after the loop, to the end of a function, etc.
Since <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> are much more limited,
they do not require such good label naming.
A <code class="highlight"><c- k>break</c-> <c- n>loop</c-></code> has bad name, but the user <em>generally</em> understands its purpose.</p>
   </ul>
   <p class="note" role="note"><span class="marker">Note:</span> Previous discussion on the <a data-link-type="biblio" href="#biblio-isocpp-core" title="Discussion regarding continue vs. goto in constant expressions">[isocpp-core]</a> reflector has addressed the idea
of just adding <code class="highlight"><c- k>constexpr</c-> <c- k>goto</c-></code>,
but doing so is alleged to be more complicated than more limited <code class="highlight"><c- k>constexpr</c-></code> control flow
structures which can only "jump forwards", such as <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code>.</p>
   <p>In conclusion, there are too many issues with <code class="highlight"><c- k>goto</c-></code>, some of which may never be resolved. <a data-link-type="biblio" href="#biblio-std-proposals" title="Bringing break/continue with label to C++">[std-proposals]</a> discussion prior to the publication of this proposal has shown once again
that <code class="highlight"><c- k>goto</c-></code> is a controversial and divisive.</p>
   <h4 class="heading settled" data-level="3.1.2" id="alternative-iile"><span class="secno">3.1.2. </span><span class="content">Immediately invoked lambda expression (IILE)</span><a class="self-link" href="#alternative-iile"></a></h4>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
    <c- p>[</c-><c- o>&amp;</c-><c- p>]</c-> <c- p>{</c->
        <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
            <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
                <c- k>return</c-><c- p>;</c->
            <c- p>}</c->
            <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
        <c- p>}</c->
        <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- p>}();</c->
<c- p>}</c->
<c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
</pre>
   <p>While this solution works in constant expressions,
we may be painting ourselves into a corner with this design.
We cannot also <code class="highlight"><c- k>break</c-></code> the surrounding loop from within the IILE,
and we cannot return from the surrounding function.
If this is needed at some point, we will have to put substantial effort into refactoring.</p>
   <p>Furthermore, this solution isn’t exactly elegant:</p>
   <ul>
    <li data-md>
     <p>The level of indentation has unnecessarily increased through the extra scope.</p>
    <li data-md>
     <p>The call stack will be one level deeper during debugging.
This may be relevant to debug build performance.</p>
    <li data-md>
     <p>The fact that the lambda is immediately invoked isn’t obvious until reading up to <code class="highlight"><c- p>()</c-></code>.</p>
    <li data-md>
     <p>The word <code class="highlight"><c- k>return</c-></code> does not express the overall intent well, which is merely to
continue the outer loop.
This can be considered a teachability downside.</p>
   </ul>
   <p>It is also possible to use an additional function instead of an IILE in this place.
However, this is arguably increasing the degree of complexity even more,
and it scatters the code across multiple functions without any substantial benefit.</p>
   <h4 class="heading settled" data-level="3.1.3" id="alternative-bool-state"><span class="secno">3.1.3. </span><span class="content">Mutable <code class="highlight"><c- b>bool</c-></code> state</span><a class="self-link" href="#alternative-bool-state"></a></h4>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
    <c- b>bool</c-> <c- n>success</c-> <c- o>=</c-> true<c- p>;</c->
    <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
            <c- n>success</c-> <c- o>=</c-> false<c- p>;</c->
            <c- k>break</c-><c- p>;</c->
        <c- p>}</c->
        <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
    <c- p>}</c->
    <c- k>if</c-> <c- p>(</c-><c- n>success</c-><c- p>)</c-> <c- p>{</c->
        <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- p>}</c->
<c- p>}</c->
<c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
</pre>
   <p>This solution substantially increases complexity.
Instead of introducing extra scope and call stack depth,
we add more mutable state to our function.
The original intent of "go process the next file" is also lost.</p>
   <p>Such a solution also needs additional state for <em>every</em> nested loop,
i.e. N <code class="highlight"><c- b>bool</c-></code>s are needed to <code class="highlight"><c- k>continue</c-></code> from N nested loops.</p>
   <h3 class="heading settled" data-level="3.2" id="constant-expressions"><span class="secno">3.2. </span><span class="content">Constant expressions</span><a class="self-link" href="#constant-expressions"></a></h3>
   <p>Use of <code class="highlight"><c- k>constexpr</c-></code> has become tremendously more common,
and <code class="highlight"><c- k>goto</c-></code> may not be used in constant expressions.
Where <code class="highlight"><c- k>goto</c-></code> is used to break out of nested loops, <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> makes it easy to migrate code:</p>
   <div class="example" id="example-5c2cd862">
    <a class="self-link" href="#example-5c2cd862"></a> Uses of <code class="highlight"><c- k>goto</c-></code> to break out of nested loops can be replaced with <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> as follows: 
<pre class="highlight"><code><ins><c- k>constexpr</c-></ins> <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <ins><c- nl>outer</c-><c- p>:</c-> </ins><c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
            <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
                <del><c- k>goto</c-> <c- n>after_loop</c-><c- p>;</c-></del>
                <ins><c- k>break</c-> <c- n>outer</c-><c- p>;</c-></ins>
            <c- p>}</c->
        <c- p>}</c->
    <c- p>}</c->
    <del><c- nl>after_loop</c-><c- p>:;</c-></del>
<c- p>}</c->
</code></pre>
   </div>
   <p>Due to reasons mentioned above,
I do not believe that "<code class="highlight"><c- k>constexpr</c-></code> <code class="highlight"><c- k>goto</c-></code>" is a path forward that will find consensus.</p>
   <h3 class="heading settled" data-level="3.3" id="argumentum-ad-populum"><span class="secno">3.3. </span><span class="content">Argumentum ad populum</span><a class="self-link" href="#argumentum-ad-populum"></a></h3>
   <p>Another reason to have <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> is simply that it’s a
popular construct, available in other languages.
When Java, JavaScript, Rust, or Kotlin developers pick up C++,
they may expect that C++ can <code class="highlight"><c- k>break</c-></code> out of nested loops as well,
but will find themselves disappointed.</p>
   <p><a data-link-type="biblio" href="#biblio-stackoverflow" title="Can I use break to exit multiple nested &apos;for&apos; loops?">[StackOverflow]</a> <i>"Can I use break to exit multiple nested <code class="highlight"><c- k>for</c-></code> loops?"</i> shows that there is interest in this feature (393K views at the time of writing).</p>
   <p>A draft of the proposal was posted on <a data-link-type="biblio" href="#biblio-reddit" title="&quot;break label;&quot; and &quot;continue label;&quot; in C++">[Reddit]</a> and received overwhelmingly positive feedback
(70K views, 143 upvotes with, 94% upvote rate at the time of writing).</p>
   <h4 class="heading settled" data-level="3.3.1" id="poll"><span class="secno">3.3.1. </span><span class="content">Poll</span><a class="self-link" href="#poll"></a></h4>
   <p>Another way to measure interest is to simply ask C++ users.
The following is a committee-style poll (source: <a data-link-type="biblio" href="#biblio-tccpp" title="Poll at Together C &amp; C++ (discord.gg/tccpp)">[TCCPP]</a>) from the Discord server <a href="https://discord.gg/tccpp">Together C &amp; C++</a>,
which is the largest server in terms of C++-focused message activity:</p>
   <blockquote>
     Should C++ have "break label" and "continue label" statements
to apply break/continue to nested loops or switches? 
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>21
       <td>21
       <td>12
       <td>6
       <td>4
    </table>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> 64 users in total voted, and the poll was active for one week.</p>
   <h4 class="heading settled" data-level="3.3.2" id="how-common-is-break-continue-label"><span class="secno">3.3.2. </span><span class="content">How common is <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> with labels?</span><a class="self-link" href="#how-common-is-break-continue-label"></a></h4>
   <p>To further quantify the popularity, we can use GitHub code search for various
languages which already support this feature.
The following table counts only control statements with a label, <em>not</em> plain <code class="highlight"><c- k>break</c-><c- p>;</c-></code>, <code class="highlight"><c- k>continue</c-><c- p>;</c-></code>, etc.
We also count statements like Perl’s <code class="highlight"><c- n>last</c-> <c- n>label</c-></code>;
it is de-facto <code class="highlight"><c- k>break</c-> <c- n>label</c-></code>, just with a different spelling.</p>
   <table>
    <tbody>
     <tr>
      <td>Language
      <td>Syntax
      <td>Labeled<br><code class="highlight"><c- k>break</c-></code>s
      <td>Labeled<br><code class="highlight"><c- k>continue</c-></code>s
      <td>Σ <code class="highlight"><c- k>break</c-></code> <code class="highlight"><c- k>continue</c-></code>
     <tr>
      <td>Java
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AJava+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">424K files</a>
      <td><a href="https://github.com/search?q=language%3AJava+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">152K files</a>
      <td>576K files
     <tr>
      <td>JavaScript
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AJavaScript+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">53.8K files</a>
      <td><a href="https://github.com/search?q=language%3AJavaScript+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">68.7K files</a>
      <td>122.5K files
     <tr>
      <td>Perl
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- n>last</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- n>next</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3APerl+%2F%28%3F-i%29last+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">34.9K files</a>
      <td><a href="https://github.com/search?q=language%3APerl+%2F%28%3F-i%29next+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">31.7K files</a>
      <td>66.6K files
     <tr>
      <td>Rust
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> '<c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> '<c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3ARust+%2F%28%3F-i%29break+%3F%27%5Ba-zA-Z0-9%5D%2B%3B%2F&amp;type=code">30.6K files</a>
      <td><a href="https://github.com/search?q=language%3ARust+%2F%28%3F-i%29continue+%3F%27%5Ba-zA-Z0-9%5D%2B%3B%2F&amp;type=code">29.1K files</a>
      <td>59.7K files
     <tr>
      <td>TypeScript
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3ATypeScript+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">11.6K files</a>
      <td><a href="https://github.com/search?q=language%3ATypeScript+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">9K files</a>
      <td>20.6K files
     <tr>
      <td>Swift
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-></code>
      <td><a href="https://github.com/search?q=language%3ASwift+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%5Cn%2F&amp;type=code">12.6K files</a>
      <td><a href="https://github.com/search?q=language%3ASwift+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%5Cn%2F&amp;type=code">5.6K files</a>
      <td>18.2K files
     <tr>
      <td>Kotlin
      <td><code class="highlight"><c- n>label</c->@ <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c->@<c- n>label</c-></code><br><code class="highlight"><c- k>continue</c->@<c- n>label</c-></code>
      <td><a href="https://github.com/search?q=language%3AKotlin+%2F%28%3F-i%29break%40%5B_a-zA-Z0-9%5D%2B%2F&amp;type=code">8.7K files</a>
      <td><a href="https://github.com/search?q=language%3AKotlin+%2F%28%3F-i%29continue%40%5B_a-zA-Z0-9%5D%2B%2F&amp;type=code">7.6K files</a>
      <td>16.3K files
     <tr>
      <td>D
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AD+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">3.5K files</a>
      <td><a href="https://github.com/search?q=language%3AD+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">2.6K files</a>
      <td>6.1K files
     <tr>
      <td>Go
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AGo+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">270 files</a>
      <td><a href="https://github.com/search?q=language%3AGo+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">252 files</a>
      <td>522
     <tr>
      <td>Ada
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- n>exit</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>Dart
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>Cpp2 (cppfront)
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>C
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>Fortran
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>do</c-> <c- p>...</c-></code><br><code class="highlight"><c- n>exit</c-> <c- n>label</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>Groovy
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>Odin
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>PL/I
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>do</c-> <c- p>...</c-></code><br><code class="highlight"><c- n>exit</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>PostgreSQL
      <td><code class="highlight"><c- o>&lt;&lt;</c-><c- n>label</c-><c- o>>></c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- n>exit</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>PowerShell
      <td><code class="highlight"><c- o>:</c-><c- n>label</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>outer</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
   </table>
   <p>Based on this, we can reasonably estimate that there are at least one million files
in the world which use labeled <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> (or an equivalent construct).</p>
   <p class="note" role="note"><span class="marker">Note:</span> This language list is not exhaustive and the search only includes open-source code bases on GitHub.
Some of the cells are N/A because the number isn’t meaningful,
or simply because I haven’t gotten around to doing the code search yet.</p>
   <h3 class="heading settled" data-level="3.4" id="c2y-compatibility"><span class="secno">3.4. </span><span class="content">C2y compatibility</span><a class="self-link" href="#c2y-compatibility"></a></h3>
   <p>Last but not least, C++ should have <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> to increase the amount of code that has a direct equivalent in C.
Such compatibility is desirable for two reasons:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- kr>inline</c-></code> functions or macros used in C/C++ interoperable headers could use the same syntax.</p>
    <li data-md>
     <p>C2y code is much easier to port to C++ (and vice-versa) if both languages support the same
control flow constructs.</p>
   </ul>
   <p>Furthermore, the adoption of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> saves EWG a substantial amount of time
when it comes to debating the syntax; the C++ syntax should certainly be C-compatible.</p>
   <h2 class="heading settled" data-level="4" id="design-considerations"><span class="secno">4. </span><span class="content">Design Considerations</span><a class="self-link" href="#design-considerations"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="alternative-break-continue-forms"><span class="secno">4.1. </span><span class="content">Alternative <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> forms</span><a class="self-link" href="#alternative-break-continue-forms"></a></h3>
   <p>While the idea of applying <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> to some surrounding construct of choice is simple,
there are infinite ways to express this.
Various ideas have been proposed over the last months and years:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- k>break</c-> <c- mi>1</c-></code>, <code class="highlight"><c- k>break</c-> <c- mi>2</c-></code>, ... (specify the amount of loops, not the targeted loop)</p>
    <li data-md>
     <p><code class="highlight"><c- k>break</c-> <c- k>while</c-></code>, <code class="highlight"><c- k>break</c-> <c- k>for</c-> <c- k>while</c-></code>, ... (target by keyword, not by label)</p>
    <li data-md>
     <p><code class="highlight"><c- k>break</c-> <c- k>break</c-></code> (execute statement in the jumped-to scope)</p>
    <li data-md>
     <p><code class="highlight"><c- k>for</c-> <c- n>name</c-> <c- p>(...)</c-></code> (competing syntax in <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>)</p>
   </ul>
   <p>All of these have been discussed in great detail in the first revision of this paper, <a data-link-type="biblio" href="#biblio-p3568r0" title="break label; and continue label;">[P3568R0]</a>.
At this point, it would be a waste of time to discuss these in detail.</p>
   <p>WG21 <em>overwhelmingly</em> agrees
(based on polls, reflector discussions, and personal conversations)
that the design should be compatible with C.
This is also reflected by a poll at Hagenberg 2025:</p>
   <blockquote>
    <p><b>P3568R0</b>: If C has it, we are interested in this feature too.</p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>16
       <td>21
       <td>5
       <td>2
       <td>1
    </table>
   </blockquote>
   <p>Furthermore, WG14 has already accepted the <code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-></code> syntax of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> into C2y, and WG14 is unwilling to revisit this syntax,
as voted at Graz 2025:</p>
   <blockquote>
    <p><b>N3377</b>: Would WG14 like to see a paper changing loop name syntax at a future meeting?</p>
    <table>
     <tbody>
      <tr>
       <td>F
       <td>N
       <td>A
      <tr>
       <td>6
       <td>11
       <td>9
    </table>
   </blockquote>
   <p>There is <em>only</em> one way forward that has a chance of finding consensus: <strong>do what C does.</strong></p>
   <h3 class="heading settled" data-level="4.2" id="changes-to-labels"><span class="secno">4.2. </span><span class="content">Changes to labels</span><a class="self-link" href="#changes-to-labels"></a></h3>
   <p>While the proposed <code class="highlight"><c- k>for</c-> <c- n>name</c-> <c- p>(...)</c-></code> syntax of <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> was de-facto rejected at Graz,
the paper brings up legitimate issues with C2y <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> after <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a>.</p>
   <p>Notably, the restriction that a label can be used only once per function is not usually
present in other languages that support <code class="highlight"><c- k>break</c-> <c- n>label</c-></code>.
This restriction is especially bad for C and C++ because if <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> was used in a macro,
that macro could only be expanded once per function:</p>
<pre class="language-cpp highlight"><c- cp>#define MACRO() outer: for (</c-><c- d>/* ... */</c-><c- cp>) for (</c-><c- d>/* ... */</c-><c- cp>) break outer;</c->

<c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- n>MACRO</c-><c- p>()</c-> <c- c1>// OK so far</c->
    <c- n>MACRO</c-><c- p>()</c-> <c- c1>// error: duplicate label 'outer'</c->
<c- p>}</c->
</pre>
   <p>The author of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> has expressed to me that he intends
to address these label issues for C2y.
In parallel, this proposal addresses such issues by relaxing label restrictions.
Presumably, C and C++ will converge on identical restrictions.</p>
   <h4 class="heading settled" data-level="4.2.1" id="design-philosophy"><span class="secno">4.2.1. </span><span class="content">Design philosophy</span><a class="self-link" href="#design-philosophy"></a></h4>
   <p>The proposed design is extremely simple:</p>
   <blockquote>
    <ol>
     <li data-md>
      <p>Drop <em>all</em> restrictions on labels.</p>
     <li data-md>
      <p>Make <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> "just work" anyway.</p>
     <li data-md>
      <p>Disallow <code class="highlight"><c- k>goto</c-> <c- n>label</c-></code> for duplicate <code class="highlight"><c- n>label</c-></code>.</p>
    </ol>
   </blockquote>
   <p>Any existing <code class="highlight"><c- k>goto</c-></code> code remains unaffected by this change.
These rules are simple and easy to remember.</p>
   <p>While it may seem too lax to put no restrictions on labels at all,
there’s no obvious problem with this.
Labels don’t declare anything, and unless referenced by <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>goto</c-></code>,
they are de-facto comments with zero influence on the labeled code.
If labels are quasi-comments, why should there be any restrictions on the labels themselves?</p>
   <p>The consequences and details of these changes are described below.</p>
   <h4 class="heading settled" data-level="4.2.2" id="new-labels-duplicates"><span class="secno">4.2.2. </span><span class="content">Allowing duplicate labels</span><a class="self-link" href="#new-labels-duplicates"></a></h4>
   <p>I propose to permit duplicate labels,
which makes the following code valid:</p>
<pre class="language-cpp highlight"><c- nl>outer</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- nl>inner</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// breaks enclosing outer while loop</c->
    <c- p>}</c->
<c- p>}</c->

<c- nl>outer</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c-> <c- c1>// OK, reusing label is permitted</c->
    <c- nl>inner</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// breaks enclosing outer while loop</c->
    <c- p>}</c->
<c- p>}</c->

<c- k>goto</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// error: ambiguous jump target</c->
</pre>
   <p>Such use of duplicate labels (possibly with different syntax)
is permitted in numerous other languages,
such as Rust, Kotlin, Java, JavaScript, TypeScript, Dart, and more.
To be fair, languages that also support <code class="highlight"><c- k>goto</c-></code> require unique labels per function,
but there’s no technical reason why the uniqueness restriction
couldn’t be placed on <code class="highlight"><c- k>goto</c-></code> rather than the labels themselves.</p>
   <p>As mentioned before, permitting such code is especially useful when these loops are not
hand-written, but expanded from a macro.
Even disregarding macros, there’s nothing innately wrong about this code,
and it is convenient to reuse common names like <code class="highlight"><c- nl>outer</c-><c- p>:</c-></code> for controlling nested loops.</p>
   <p class="note" role="note"><span class="marker">Note:</span> Existing code using <code class="highlight"><c- k>goto</c-></code> is unaffected
because existing code cannot have duplicate labels in the first place.</p>
   <h4 class="heading settled" data-level="4.2.3" id="new-labels-nesting"><span class="secno">4.2.3. </span><span class="content">Reusing labels in nested loops</span><a class="self-link" href="#new-labels-nesting"></a></h4>
   <p>A more controversial case is the following:</p>
<pre class="language-cpp highlight"><c- nl>l</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- nl>l</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>l</c-><c- p>;</c-> <c- c1>// equivalent to break;</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   <p><code class="highlight"><c- k>break</c-> <c- n>l</c-></code> generally applies to the innermost loop labeled <code class="highlight"><c- nl>l</c-><c- p>:</c-></code>,
so the inner loop is targeted here.
I believe that this code should be valid
because it keeps the label restrictions stupidly simple (there are none),
and because this feature may be useful to developers.</p>
   <p>One may run into this case when nesting pairs of <code class="highlight"><c- nl>outer</c-><c- p>:</c-></code>/<code class="highlight"><c- nl>inner</c-><c- p>:</c-></code> loops in each other "manually",
or when an <code class="highlight"><c- nl>l</c-><c- p>:</c-></code>-labeled loop in a macro is expanded into a surrounding loop that also uses <code class="highlight"><c- nl>l</c-><c- p>:</c-></code>.</p>
   <p class="note" role="note"><span class="marker">Note:</span> This code is not valid Java or JavaScript, but is valid Rust when using the label <code class="highlight">'<c- n>l</c-></code>.</p>
   <h4 class="heading settled" data-level="4.2.4" id="new-labels-duplicates-on-same-statement"><span class="secno">4.2.4. </span><span class="content">Duplicate labels on the <em>same</em> statement</span><a class="self-link" href="#new-labels-duplicates-on-same-statement"></a></h4>
   <p>A more extreme form of the scenario above is:</p>
<pre class="language-cpp highlight"><c- nl>l</c-><c- p>:</c-> <c- n>l</c-><c- o>:</c-> <c- n>l</c-><c- o>:</c-> <c- n>l</c-><c- o>:</c-> <c- n>f</c-><c- p>();</c->
</pre>
   <p>I also believe that this code should be valid because it’s not harmful,
and may be useful in certain, rare situations (see below).
Once again, allowing it keeps the label restrictions stupidly simple.</p>
<pre class="language-cpp highlight"><c- c1>// common idiom on C: expand loops from macros</c->
<c- cp>#define MY_LOOP_MACRO(...) outer: for (</c-><c- d>/* ... */</c-><c- cp>)</c->

<c- nl>outer</c-><c- p>:</c-> <c- n>MY_LOOP_MACRO</c-><c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>outer</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>If <code class="highlight"><c- n>MY_LOOP_MACRO</c-></code> already uses an <code class="highlight"><c- nl>outer</c-><c- p>:</c-></code> label internally,
perhaps because it expands to two nested loops and uses <code class="highlight"><c- k>continue</c-> <c- n>outer</c-><c- p>;</c-></code> itself,
then the macro effectively expands to <code class="highlight"><c- nl>outer</c-><c- p>:</c-> <c- n>outer</c-><c- o>:</c-></code>.
This forces the user to come up with a new label now,
for no apparent reason.</p>
   <h4 class="heading settled" data-level="4.2.5" id="new-labels-break-label-multiple"><span class="secno">4.2.5. </span><span class="content"><code class="highlight"><c- k>break</c-> <c- n>label</c-></code> for loops with more than one label</span><a class="self-link" href="#new-labels-break-label-multiple"></a></h4>
   <p>Another case to consider is this:</p>
<pre class="language-cpp highlight"><c- nl>x</c-><c- p>:</c-> <c- n>y</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>x</c-><c- p>;</c-> <c- c1>// OK in C2y</c->
<c- p>}</c->
</pre>
   <p><a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> makes wording changes to C so that the code above is valid.
For C2y compatibility and convenience, we also make this valid.
We don’t change the C++ grammar to accomplish this,
but define the term <em>(to) label (a statement)</em>,
where <code class="highlight"><c- n>x</c-></code> labels <code class="highlight"><c- k>while</c-></code>.</p>
   <h2 class="heading settled" data-level="5" id="impact-on-existing-code"><span class="secno">5. </span><span class="content">Impact on existing code</span><a class="self-link" href="#impact-on-existing-code"></a></h2>
   <p>No existing code becomes ill-formed or has its meaning altered.
This proposal merely permits code which was previously ill-formed,
and relaxes restrictions on the placement of labels.</p>
   <h2 class="heading settled" data-level="6" id="implementation-experience"><span class="secno">6. </span><span class="content">Implementation experience</span><a class="self-link" href="#implementation-experience"></a></h2>
   <p>An LLVM implementation is W.I.P.</p>
   <p>A GCC implementation of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> has also been committed at <a data-link-type="biblio" href="#biblio-gcc" title="c: Implement C2Y N3355 - Named Loops [PR117022]">[GCC]</a>.</p>
   <h2 class="heading settled" data-level="7" id="proposed-wording"><span class="secno">7. </span><span class="content">Proposed wording</span><a class="self-link" href="#proposed-wording"></a></h2>
   <p>The wording is relative to <a data-link-type="biblio" href="#biblio-n5001" title="Working Draft, Programming Languages — C++">[N5001]</a>.</p>
   <p>Update <a href="https://eel.is/c++draft/stmt.label">[stmt.label]</a> paragraph 1 as follows:</p>
   <blockquote>
     A label can be added to a statement or used anywhere in a <em>compound-statement</em>. 
    <div class="indent">
      <em>label</em>:<br> 
     <div class="indent"> <em>attribute-specifier-seq</em><sub>opt</sub> <em>identifier</em> <code class="highlight"><c- o>:</c-></code><br> <em>attribute-specifier-seq</em><sub>opt</sub> <code class="highlight"><c- k>case</c-></code> <em>constant-expression</em> <code class="highlight"><c- o>:</c-></code><br> <em>attribute-specifier-seq</em><sub>opt</sub> <code class="highlight"><c- k>default</c-></code> <code class="highlight"><c- o>:</c-></code> </div>
      <em>labeled-statement</em>:<br> 
     <div class="indent"> <em>label</em> <em>statement</em> </div>
    </div>
     The optional <em>attribute-specifier-seq</em> appertains to the label. 
    <del>The only use of a label with an <em>identifier</em> is as the target of a <code class="highlight"><c- k>goto</c-></code>.
No two labels in a function shall have the same identifier.</del>
     A label can be used in a <code class="highlight"><c- k>goto</c-></code> statement 
    <ins>([stmt.goto])</ins>
     before its introduction.
    <ins><br><br> [ <em>Note</em>: Multiple identical labels within the same function are permitted,
    but such duplicate labels cannot be used in a <code class="highlight"><c- k>goto</c-></code> statement. — <em>end note</em> ] </ins>
   </blockquote>
   <p>In <a href="https://eel.is/c++draft/stmt.label">[stmt.label]</a> insert a new paragraph after paragraph 1:</p>
   <blockquote>
    <ins>
     A label <strong>L</strong> of the form <em>attribute-specifier-seq</em><sub>opt</sub> <em>identifier</em> <code class="highlight"><c- o>:</c-></code> <em>labels</em> the <em>statement</em> <strong>S</strong> of a <em>labeled-statement</em> <strong>X</strong> if 
     <ul>
      <li><strong>L</strong> is the <em>label</em> of <strong>X</strong>, or
      <li><strong>L</strong> labels <strong>X</strong> (recursively).
     </ul>
    </ins>
    <div class="ins-block">
      [ <em>Example</em>: 
<pre class="highlight"><c- nl>a</c-><c- p>:</c-> <c- n>b</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c-><c- mi>0</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->            <c- c1>// both a: and b: label the loop</c->
<c- nl>c</c-><c- p>:</c-> <c- p>{</c-> <c- n>d</c-><c- o>:</c-> <c- k>switch</c-> <c- p>(</c-><c- mi>0</c-><c- p>)</c-> <c- p>{</c->           <c- c1>// unlike c:, d: labels the switch statement</c->
    <c- k>default</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c-><c- mi>0</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->     <c- c1>// default: labels nothing</c->
<c- p>}</c-> <c- p>}</c->
</pre>
     — <em>end example</em> ]
    </div>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> This defines the term <em>(to) label</em>, which is used extensively below.
We also don’t want <code class="highlight"><c- k>case</c-></code> or <code class="highlight"><c- k>default</c-></code> labels to label statements, since this would inadvertently
permit <code class="highlight"><c- k>break</c-> <c- n>i</c-></code> given <code class="highlight"><c- k>case</c-> <c- no>i</c-><c- p>:</c-></code>, considering how we word [stmt.break].</p>
   <p>Update <a href="https://eel.is/c++draft/stmt.label">[stmt.label]</a> paragraph 3 as follows:</p>
   <blockquote>
     A <em>control-flow-limited statement</em> is a statement <strong>S</strong> for which: 
    <ul>
     <li> a <code class="highlight"><c- k>case</c-></code> or <code class="highlight"><c- k>default</c-></code> label appearing within <strong>S</strong> shall be associated with a <code class="highlight"><c- k>switch</c-></code> statement ([stmt.switch]) within <strong>S</strong>, and 
     <li>
       a label declared in <strong>S</strong> shall only be
        referred to by a statement 
      <del>([stmt.goto])</del>
       in <strong>S</strong>. 
    </ul>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> While the restriction still primarily applies to <code class="highlight"><c- k>goto</c-></code> (preventing the user from e.g. jumping into an <code class="highlight"><c- k>if</c-> <c- k>constexpr</c-></code> statement),
if other statements can also refer to labels, it is misleading to say
"statement ([stmt.goto])" as if <code class="highlight"><c- k>goto</c-></code> was the only relevant statement.</p>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.jump.general">[stmt.jump.general]</a> paragraph 1 as follows:</p>
   <blockquote>
     Jump statements unconditionally transfer control. 
    <div class="indent">
      <em>jump-statement</em>: 
     <div class="indent">
      <ins><code class="highlight"><c- k>goto</c-></code> <em>identifier</em> <code class="highlight"><c- p>;</c-></code></ins>
      <br> <code class="highlight"><c- k>break</c-></code> 
      <ins><em>identifier</em><sub>opt</sub></ins>
       <code class="highlight"><c- p>;</c-></code><br> <code class="highlight"><c- k>continue</c-></code> 
      <ins><em>identifier</em><sub>opt</sub></ins>
       <code class="highlight"><c- p>;</c-></code><br> <code class="highlight"><c- k>return</c-></code> <em>expr-or-braced-init-list</em><sub>opt</sub> <code class="highlight"><c- p>;</c-></code><br> 
      <del><code class="highlight"><c- k>goto</c-></code> <em>identifier</em> <code class="highlight"><c- p>;</c-></code></del>
      <br> 
     </div>
    </div>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> <code class="highlight"><c- k>goto</c-></code> is being relocated to the top so that all the jump statements with an <em>identifier</em> are grouped together.
Of these three, <code class="highlight"><c- k>goto</c-></code> is being listed first because it models the concept of
"jumping somewhere" most literally; every following statement is more sophisticated or even
defined as equivalent to <code class="highlight"><c- k>goto</c-></code> (in the case of <code class="highlight"><c- k>continue</c-></code>).</p>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.break">[stmt.break]</a> paragraph 1 as follows:</p>
   <blockquote>
    <ins>A <em>breakable statement</em> is
an <em>iteration-statement</em> ([stmt.iter]) or a <code class="highlight"><c- k>switch</c-></code> statement ([stmt.switch]).</ins>
     A <code class="highlight"><c- k>break</c-></code> statement shall be enclosed by ([stmt.pre]) 
    <ins>a breakable statement</ins>
    <del>an <em>iteration-statement</em> ([stmt.iter]) or a <code class="highlight"><c- k>switch</c-></code> statement ([stmt.switch])</del>
    . 
    <ins>If present, the <em>identifier</em> shall be part of a label <strong>L</strong> which labels ([stmt.label]) an enclosing breakable statement.</ins>
     The <code class="highlight"><c- k>break</c-></code> statement causes termination of
    <ins>:</ins>
    <del>the smallest such enclosing statement;</del>
    <ul>
     <li>
      <ins>if an <em>identifier</em> is present, the smallest enclosing breakable statement labeled by <strong>L</strong>,</ins>
     <li>
      <ins>otherwise, the smallest enclosing breakable statement.</ins>
    </ul>
    <del>control</del>
    <ins>Control</ins>
     passes to the statement following the terminated statement, if any. <br><br> 
    <div class="ins-block">
      [ <em>Example</em>: 
<pre class="highlight"><c- nl>a</c-><c- p>:</c-> <c- n>b</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- nl>a</c-><c- p>:</c-> <c- n>a</c-><c- o>:</c-> <c- n>c</c-><c- o>:</c-> <c- k>for</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- k>break</c-><c- p>;</c->              <c- c1>// OK, terminates enclosing for loop</c->
        <c- k>break</c-> <c- n>a</c-><c- p>;</c->            <c- c1>// OK, same</c->
        <c- k>break</c-> <c- n>b</c-><c- p>;</c->            <c- c1>// OK, terminates enclosing while loop</c->
        <c- nl>y</c-><c- p>:</c-> <c- p>{</c-> <c- k>break</c-> <c- n>y</c-><c- p>;</c-> <c- p>}</c->     <c- c1>// error: break does not refer to a breakable statement</c->
    <c- p>}</c->
    <c- k>break</c-> <c- n>c</c-><c- p>;</c->                <c- c1>// error: break does not refer to an enclosing statement</c->
<c- p>}</c->
<c- k>break</c-><c- p>;</c->                      <c- c1>// error: break is not enclosed by a breakable statement</c->
</pre>
     — <em>end example</em> ]
    </div>
   </blockquote>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.cont">[stmt.cont]</a> paragraph 1 as follows:</p>
   <blockquote>
     A <code class="highlight"><c- k>continue</c-></code> statement shall be enclosed by ([stmt.pre]) an <em>iteration-statement</em> ([stmt.iter]). 
    <ins>If present, the <em>identifier</em> shall be part of a label <strong>L</strong> which labels ([stmt.label]) an enclosing <em>iteration-statement</em>.</ins>
     The <code class="highlight"><c- k>continue</c-></code> statement causes control to pass to the loop-continuation portion of
    <ins>:</ins>
    <del>the smallest such enclosing statement, that is, to the end of the loop.</del>
    <ul>
     <li>
      <ins>if an <em>identifier</em> is present, the smallest enclosing <em>iteration-statement</em> labeled by <strong>L</strong>,</ins>
     <li>
      <ins>otherwise, the smallest enclosing <em>iteration-statement</em>.</ins>
    </ul>
     More precisely, in each of the statements 
<pre class="highlight"><ins><c- nl>label</c-><c- p>:</c-> </ins><c- k>while</c-> <c- p>(</c-><c- n>foo</c-><c- p>)</c-> <c- p>{</c->
  <c- p>{</c->
    <c- c1>// ...</c->
  <c- p>}</c->
<c- nl>contin</c-><c- p>:</c-> <c- p>;</c->
<c- p>}</c->

<ins><c- nl>label</c-><c- p>:</c-> </ins><c- k>do</c-> <c- p>{</c->
  <c- p>{</c->
    <c- c1>// ...</c->
  <c- p>}</c->
<c- nl>contin</c-><c- p>:</c-> <c- p>;</c->
<c- p>}</c-> <c- k>while</c-> <c- p>(</c-><c- n>foo</c-><c- p>);</c->

<ins><c- nl>label</c-><c- p>:</c-> </ins><c- k>for</c-> <c- p>(;;)</c-> <c- p>{</c->
  <c- p>{</c->
    <c- c1>// ...</c->
  <c- p>}</c->
<c- nl>contin</c-><c- p>:</c-> <c- p>;</c->
<c- p>}</c->
</pre>
    <del>a <code class="highlight"><c- k>continue</c-></code> not contained in an an enclosed iteration statement is equivalent to <code class="highlight"><c- k>goto</c-> <c- n>contin</c-></code>.</del>
    <ins>
     the following are equivalent to <code class="highlight"><c- k>goto</c-> <c- n>contin</c-></code>: 
     <ul>
      <li>A <code class="highlight"><c- k>continue</c-></code> not contained in an an enclosed iteration statement.
      <li>A <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> not contained in an enclosed iteration statement labeled <code class="highlight"><c- nl>label</c-><c- p>:</c-></code>.
     </ul>
    </ins>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> The clarification "that is, to the end of the loop"
was dropped entirely based on community feedback.
"the end of the loop" is not all that much clearer either, and the whole <code class="highlight"><c- k>goto</c-></code> equivalence portion
should make it clear enough what the behavior is.</p>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.goto">[stmt.goto]</a> paragraph 1 as follows:</p>
   <blockquote>
     The <code class="highlight"><c- k>goto</c-></code> statement unconditionally transfers control to 
    <del>the</del>
    <ins>a</ins>
     statement
labeled 
    <ins>([stmt.label])</ins>
     by 
    <del>the identifier</del>
    <ins>a <em>label</em> in the current function containing <em>identifier</em></ins>
    . 
    <del>The identifier shall be a label located in the current function.</del>
    <ins>There shall be exactly one such label.</ins>
   </blockquote>
   <div class="note" role="note"> <span class="marker">Note:</span> This wording has always been defective and our proposal fixes this.
The term "to label" was never defined,
and the requirement that an identifier shall be a label is impossible to satisfy because
a label ends with a <code class="highlight"><c- o>:</c-></code>, and an <em>identifier</em> in itself would never match the <em>label</em> rule. </div>
   <hr>
   <p>Add a feature-test macro to <a href="https://eel.is/c++draft/tab:cpp.predefined.ft">[tab:cpp.predefined.ft]</a> as follows:</p>
   <blockquote>
    <table>
     <tbody>
      <tr>
       <th>Macro name
       <th>Value
      <tr>
       <td>
        <ins><code class="highlight"><c- n>__cpp_break_label</c-></code></ins>
       <td>
        <ins><code class="highlight"><c- mi>20</c-><c- o>????</c-><c- n>L</c-></code></ins>
    </table>
   </blockquote>
   <h2 class="heading settled" data-level="8" id="acknowledgements"><span class="secno">8. </span><span class="content">Acknowledgements</span><a class="self-link" href="#acknowledgements"></a></h2>
   <p>I thank Sebastian Wittmeier for providing a list of languages that support both <code class="highlight"><c- k>goto</c-></code> and <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- n>last</c-></code> with the same label syntax.</p>
   <p>I think Arthur O’Dwyer and Jens Maurer for providing wording feedback and improvement suggestions.</p>
   <p>I especially thank Arthur O’Dwyer for helping me expand the list in <a href="#how-common-is-break-continue-label">§ 3.3.2 How common is break/continue with labels?</a>.
An even more complete list may be available at <a data-link-type="biblio" href="#biblio-arthurblog" title="Arthur O&apos; Dwyer">[ArthurBlog]</a>.</p>
   <p>I thank the <a href="https://discord.gg/tccpp">Together C &amp; C++</a> community for responding to my poll; see <a data-link-type="biblio" href="#biblio-tccpp" title="Poll at Together C &amp; C++ (discord.gg/tccpp)">[TCCPP]</a>.</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="normative"><span class="content">Normative References</span><a class="self-link" href="#normative"></a></h3>
  <dl>
   <dt id="biblio-n5001">[N5001]
   <dd>Thomas Köppe. <a href="https://wg21.link/n5001"><cite>Working Draft, Programming Languages — C++</cite></a>. 17 December 2024. URL: <a href="https://wg21.link/n5001">https://wg21.link/n5001</a>
  </dl>
  <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-arthurblog">[ArthurBlog]
   <dd>Arthur O' Dwyer. <a href="https://quuxplusone.github.io/blog/2024/12/20/labeled-loops/"><cite>Arthur O' Dwyer</cite></a>. URL: <a href="https://quuxplusone.github.io/blog/2024/12/20/labeled-loops/">https://quuxplusone.github.io/blog/2024/12/20/labeled-loops/</a>
   <dt id="biblio-cppcoreguidelineses76">[CppCoreGuidelinesES76]
   <dd>CppCoreGuidelines contributors. <a href="https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-goto"><cite>CppCoreGuidelines/ES.76: Avoid goto</cite></a>. URL: <a href="https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-goto">https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-goto</a>
   <dt id="biblio-gcc">[GCC]
   <dd>Jakub Jelinek. <a href="https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=50f27896adb272b40ab03a56fd192e74789bef97"><cite>c: Implement C2Y N3355 - Named Loops [PR117022]</cite></a>. URL: <a href="https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=50f27896adb272b40ab03a56fd192e74789bef97">https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=50f27896adb272b40ab03a56fd192e74789bef97</a>
   <dt id="biblio-gotoconsideredharmful">[GotoConsideredHarmful]
   <dd>Edgar Dijkstra. <a href="https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf"><cite>Go To Statement Considered Harmful</cite></a>. 1968. URL: <a href="https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf">https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf</a>
   <dt id="biblio-isocpp-core">[ISOCPP-CORE]
   <dd>CWG. <a href="https://lists.isocpp.org/core/2023/05/14228.php"><cite>Discussion regarding continue vs. goto in constant expressions</cite></a>. URL: <a href="https://lists.isocpp.org/core/2023/05/14228.php">https://lists.isocpp.org/core/2023/05/14228.php</a>
   <dt id="biblio-misra-c">[MISRA-C++]
   <dd>MISRA Consortium Limited. <a href="https://misra.org.uk/product/misra-cpp2023/"><cite>MISRA C++:2023</cite></a>. URL: <a href="https://misra.org.uk/product/misra-cpp2023/">https://misra.org.uk/product/misra-cpp2023/</a>
   <dt id="biblio-n3355">[N3355]
   <dd>Alex Celeste. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm"><cite>N3355: Named loops, v3</cite></a>. 2024-09-18. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm</a>
   <dt id="biblio-n3377">[N3377]
   <dd>Erich Keane. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3377.pdf"><cite>N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355</cite></a>. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3377.pdf">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3377.pdf</a>
   <dt id="biblio-n3435">[N3435]
   <dd>JeanHeyd Meneide; Freek Wiedijk. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3435.pdf"><cite>ISO/IEC 9899:202y (en) — n3435 working draft</cite></a>. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3435.pdf">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3435.pdf</a>
   <dt id="biblio-n3879">[N3879]
   <dd>Andrew Tomazos. <a href="https://wg21.link/n3879"><cite>Explicit Flow Control: break label, goto case and explicit switch</cite></a>. 16 January 2014. URL: <a href="https://wg21.link/n3879">https://wg21.link/n3879</a>
   <dt id="biblio-n4327">[N4327]
   <dd>Ville Voutilanen. <a href="https://wg21.link/n4327"><cite>C++ Standard Evolution Closed Issues List (Revision R10)</cite></a>. 21 November 2014. URL: <a href="https://wg21.link/n4327">https://wg21.link/n4327</a>
   <dt id="biblio-p3568r0">[P3568R0]
   <dd>Jan Schultke, Sarah Quiñones. <a href="https://wg21.link/p3568r0"><cite>break label; and continue label;</cite></a>. 12 January 2025. URL: <a href="https://wg21.link/p3568r0">https://wg21.link/p3568r0</a>
   <dt id="biblio-reddit">[Reddit]
   <dd>Jan Schultke. <a href="https://www.reddit.com/r/cpp/comments/1hwdskt/break_label_and_continue_label_in_c/"><cite>"break label;" and "continue label;" in C++</cite></a>. URL: <a href="https://www.reddit.com/r/cpp/comments/1hwdskt/break_label_and_continue_label_in_c/">https://www.reddit.com/r/cpp/comments/1hwdskt/break_label_and_continue_label_in_c/</a>
   <dt id="biblio-stackoverflow">[StackOverflow]
   <dd>Faken. <a href="https://stackoverflow.com/q/1257744/5740428"><cite>Can I use break to exit multiple nested 'for' loops?</cite></a>. 10 Aug 2009. URL: <a href="https://stackoverflow.com/q/1257744/5740428">https://stackoverflow.com/q/1257744/5740428</a>
   <dt id="biblio-std-proposals">[STD-PROPOSALS]
   <dd>Jan Schultke. <a href="https://lists.isocpp.org/std-proposals/2024/12/11838.php"><cite>Bringing break/continue with label to C++</cite></a>. URL: <a href="https://lists.isocpp.org/std-proposals/2024/12/11838.php">https://lists.isocpp.org/std-proposals/2024/12/11838.php</a>
   <dt id="biblio-tccpp">[TCCPP]
   <dd><a href="https://discord.com/channels/331718482485837825/851121440425639956/1318965556128383029"><cite>Poll at Together C &amp; C++ (discord.gg/tccpp)</cite></a>. URL: <a href="https://discord.com/channels/331718482485837825/851121440425639956/1318965556128383029">https://discord.com/channels/331718482485837825/851121440425639956/1318965556128383029</a>
  </dl>