<!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>P3477R3: There are exactly 8 bits in a byte</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 d765c696b, updated Fri Mar 8 15:58:52 2024 -0800" name="generator">
  <link href="http://wg21.link/P3477r3" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="9f7949f7fd43a578dd0dda303d0ff87570ac42c9" name="revision">
  <meta content="dark light" name="color-scheme">
<style>
table, th, td { border: 2px solid grey; }
ins { color: #080; }

/* who needs 2D graphics in C++ when you have CSS? */
@keyframes shake {
  0% { transform: translateX(0) rotate(0); }
  20% { transform: translateX(-1px) rotate(-1deg); }
  40% { transform: translateX(1px) rotate(1deg); }
  60% { transform: translateX(-1px) rotate(-1deg); }
  80% { transform: translateX(1px) rotate(1deg); }
  100% { transform: translateX(0) rotate(0); }
}
.shaking { font-size: 2em; font-weight: bold; animation: shake 0.5s ease-in-out infinite; }
</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">P3477R3<br>There are exactly 8 bits in a byte</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-02-09">2025-02-09</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="http://wg21.link/P3477r3">http://wg21.link/P3477r3</a>
     <dt class="editor">Author:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:cxx@jfbastien.com">JF Bastien</a> (<span class="p-org org">Woven by Toyota</span>)
     <dt>Audience:
     <dd>CWG, LWG, LEWG
     <dt>Project:
     <dd>ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
     <dt>Source:
     <dd><a href="https://github.com/jfbastien/papers/blob/master/source/P3477r3.bs">github.com/jfbastien/papers/blob/master/source/P3477r3.bs</a>
     <dt>C++ Standard Base:
     <dd><a href="https://github.com/cplusplus/draft/commit/5d16ad051cad754b49057c456d64bf50c9180688"><tt>5d16ad051cad754b49057c456d64bf50c9180688</tt></a>
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </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="#yawn"><span class="secno">1</span> <span class="content">Revision History</span></a>
     <ol class="toc">
      <li><a href="#r0"><span class="secno">1.1</span> <span class="content">r0</span></a>
      <li><a href="#r1"><span class="secno">1.2</span> <span class="content">r1</span></a>
      <li><a href="#r2"><span class="secno">1.3</span> <span class="content">r2</span></a>
      <li><a href="#r3"><span class="secno">1.4</span> <span class="content">r3</span></a>
     </ol>
    <li><a href="#ratio"><span class="secno">2</span> <span class="content">Rationale</span></a>
    <li><a href="#yay"><span class="secno">3</span> <span class="content">Motivation</span></a>
    <li><a href="#c"><span class="secno">4</span> <span class="content">Impact on C</span></a>
    <li><a href="#thereareotherlanguages"><span class="secno">5</span> <span class="content">Other languages</span></a>
    <li><a href="#abiabiabi"><span class="secno">6</span> <span class="content">ABI Break! 💥</span></a>
    <li><a href="#lolno"><span class="secno">7</span> <span class="content"><code class="highlight"><c- b>short</c-></code> is 16, <code class="highlight"><c- b>int</c-></code> is 32, and more changes</span></a>
    <li>
     <a href="#word"><span class="secno">8</span> <span class="content">Wording</span></a>
     <ol class="toc">
      <li><a href="#lang-word"><span class="secno">8.1</span> <span class="content">Language</span></a>
      <li><a href="#lib-word"><span class="secno">8.2</span> <span class="content">Library</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <p><strong>Abstract: </strong><code class="highlight"><c- mi>8</c-></code>ers gonna <code class="highlight"><c- mi>8</c-></code>.</p>
   <h2 class="heading settled" data-level="1" id="yawn"><span class="secno">1. </span><span class="content">Revision History</span><a class="self-link" href="#yawn"></a></h2>
   <h3 class="heading settled" data-level="1.1" id="r0"><span class="secno">1.1. </span><span class="content">r0</span><a class="self-link" href="#r0"></a></h3>
   <p><a data-link-type="biblio" href="#biblio-p3477r0" title="There are exactly 8 bits in a byte">[P3477R0]</a> was the first published version of the paper, prompted by internet denizens nerd-sniping the author into writing the paper. There was much rejoicing.</p>
   <h3 class="heading settled" data-level="1.2" id="r1"><span class="secno">1.2. </span><span class="content">r1</span><a class="self-link" href="#r1"></a></h3>
   <p><a data-link-type="biblio" href="#biblio-p3477r1" title="There are exactly 8 bits in a byte">[P3477r1]</a> was revised a month later, after the internet denizens read the paper and provided substantial feedback regarding exotic architectures, and pointing out some embarrassing typos. In that period, a few internet denizens showed once more that they don’t read papers and only read the title, commenting on things that are already in the paper. The author would scold them here, but realizes the futility of even mentioning this shortcoming.</p>
   <p>The C++ committee’s Evolution Working Group <a href="https://github.com/cplusplus/papers/issues/2131#issuecomment-2491532773">also reviewed the paper</a>, with the following outcome:</p>
   <blockquote>
     Poll: D3477r1: There are exactly 8 bits in a byte: forward to CWG/LEWG for inclusion in C++26, removing the <code class="highlight"><c- n>intptr</c-></code>/<code class="highlight"><c- n>uintptr</c-></code> changes. 
    <table>
     <thead>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
     <tbody>
      <tr>
       <td> 9 
       <td> 17 
       <td> 3 
       <td> 4 
       <td> 0 
    </table>
    <p>Result: consensus in favor</p>
   </blockquote>
   <h3 class="heading settled" data-level="1.3" id="r2"><span class="secno">1.3. </span><span class="content">r2</span><a class="self-link" href="#r2"></a></h3>
   <p>Revision r1 was <a href="https://github.com/cplusplus/papers/issues/2131#issuecomment-2577359770">seen by the C++ committee’s SG22 C/C++ Liaison Group</a>, with the following outcome:</p>
   <blockquote> We think WG14 might be interested too, perhaps with a change to hosted environments only.
  No concerns raised from SG22 perspective. </blockquote>
   <p>No other changes to the paper besides removing SG22 from the audience list.</p>
   <h3 class="heading settled" data-level="1.4" id="r3"><span class="secno">1.4. </span><span class="content">r3</span><a class="self-link" href="#r3"></a></h3>
   <p>A lengthy LEWG email discussion took place. The salient points reflected in the updated paper are:</p>
   <ul>
    <li data-md>
     <p>Expansion of the discussion on <code class="highlight"><c- b>int16_t</c-></code>, <code class="highlight"><c- b>int32_t</c-></code>, <code class="highlight"><c- b>int64_t</c-></code> and their <code class="highlight"><c- b>unsigned</c-></code> variants, leading to a wording update to clarify the [<strong>cstdint.syn</strong>] changes, and adding changes to [<strong>basic.fundamental</strong>]. See <a href="#abiabiabi">§ 6 ABI Break! 💥</a> and <a href="#lolno">§ 7 short is 16, int is 32, and more changes</a>, and the updates in <a href="#word">§ 8 Wording</a>.</p>
    <li data-md>
     <p>More motivation regarding complexity in <a href="#yay">§ 3 Motivation</a>.</p>
   </ul>
   <p>An astute reader pointed out a missing editorial edit to an example hidden deep within [<strong>dcl.init.list</strong>]. It is now in <a href="#word">§ 8 Wording</a>.</p>
   <p>A section on other languages and their choice of bytes was added in <a href="#thereareotherlanguages">§ 5 Other languages</a>.</p>
   <p>LEWG has requested that EWG review the updated paper.</p>
   <p><a href="https://wiki.edg.com/bin/edit/Wg21hagenberg2025/NotesEWGP3477">EWG did so in Hagenberg</a>, and took the following poll:</p>
   <blockquote>
     Poll: D3477R3: There are exactly 8 bits in a byte: Having heard the feedback from LEWG’s Reflector review, as well as the response, EWG re-affirms its vote to forward D3477R3 to CWG/LEWG for inclusion in C++26. 
    <table>
     <thead>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
     <tbody>
      <tr>
       <td> 21 
       <td> 12 
       <td> 3 
       <td> 0 
       <td> 1 
    </table>
    <p>Consensus in favor.</p>
   </blockquote>
   <h2 class="heading settled" data-level="2" id="ratio"><span class="secno">2. </span><span class="content">Rationale</span><a class="self-link" href="#ratio"></a></h2>
   <p>C has the <code class="highlight"><c- n>CHAR_BIT</c-></code> macro which contains the implementation-defined number of bits in a byte, without restrictions on the value of this number. C++ imports this macro as-is. Many other macros and character traits have values derived from <code class="highlight"><c- n>CHAR_BIT</c-></code>. While this was historically relevant in computing’s early days, modern hardware has overwhelmingly converged on the assumption that a byte is 8 bits. This document proposes that C++ formally mandates that a byte is 8 bits.</p>
   <p>Mainstream compilers already support this reality:</p>
   <ul>
    <li data-md>
     <p>GCC <a href="https://github.com/gcc-mirror/gcc/blob/e7380688fa5917011c3fb85b5e06fb00f776a95d/gcc/genmodes.cc#L837">sets a default value of <code class="highlight"><c- mi>8</c-></code></a> but <a href="https://github.com/search?q=repo%3Agcc-mirror%2Fgcc%20BITS_PER_UNIT%20path%3A%22gcc%2Fconfig%2F%22&amp;type=code">no upstream target changes the default</a>;</p>
    <li data-md>
     <p><a href="https://github.com/llvm/llvm-project/blob/7ec32094933bbf0201ea0670209c090a00bf8d83/clang/lib/Frontend/InitPreprocessor.cpp#L1103">LLVM sets <code class="highlight"><c- n>__CHAR_BIT__</c-></code> to <code class="highlight"><c- mi>8</c-></code></a>; and</p>
    <li data-md>
     <p><a href="https://learn.microsoft.com/en-us/cpp/c-runtime-library/data-type-constants">MSVC defines <code class="highlight"><c- n>CHAR_BIT</c-></code> to <code class="highlight"><c- mi>8</c-></code></a>.</p>
   </ul>
   <p>We can find vestigial support, for example GCC dropped <a href="https://github.com/gcc-mirror/gcc/commit/a4a4b1d36476aaa60ebd05db0dfd16145dc72338#diff-d074f0fa705c64c47c773f7a884ecf60ee9699c1dbff6295c5ca535558b9a8b8">dsp16xx in 2004</a>, and <a href="https://github.com/gcc-mirror/gcc/commit/c7bdf0a6af41a480ecb6a103636ef9069721c0bd#diff-5386a7d0786c0a34dfad58442a8bfa9225ac1b3db899af287bf610d5be7360e9L94">1750a in 2002</a>. Search <a href="https://www.google.com/search?q=%22define+BITS_PER_UNIT%22+-%22define+BITS_PER_UNIT+8%22">the web for more evidence</a> finds a few GCC out-of-tree ports which do not seem relevant to modern C++.</p>
   <p><a data-link-type="biblio" href="#biblio-posix" title="The Open Group Base Specifications Issue 8">[POSIX]</a> has mandated this reality since POSIX.1-2001 (or IEEE Std 1003.1-2001), saying:</p>
   <blockquote>
    <p>As a consequence of adding <code class="highlight"><c- b>int8_t</c-></code>, the following are true:</p>
    <ul>
     <li data-md>
      <p>A byte is exactly 8 bits.</p>
     <li data-md>
      <p><code class="highlight"><c- n>CHAR_BIT</c-></code> has the value 8, <code class="highlight"><c- n>SCHAR_MAX</c-></code> has the value 127, <code class="highlight"><c- n>SCHAR_MIN</c-></code> has the value -128, and <code class="highlight"><c- n>UCHAR_MAX</c-></code> has the value 255.</p>
    </ul>
    <p>Since the POSIX.1 standard explicitly requires 8-bit char with two’s complement arithmetic, it is easier for application writers if the same two’s complement guarantees are extended to all of the other standard integer types. Furthermore, in programming environments with a 32-bit long, some POSIX.1 interfaces, such as <code class="highlight"><c- n>mrand48</c-><c- p>()</c-></code>, cannot be implemented if long does not use a two’s complement representation.</p>
   </blockquote>
   <p>To add onto the reality that POSIX chose in 2001, C++20 has only supported two’s complement storage since <a data-link-type="biblio" href="#biblio-p0907r4" title="Signed Integers are Two’s Complement">[P0907r4]</a>, and C23 has followed suit.</p>
   <p>The overwhelming support for 8-bit bytes in hardware and software platforms means that software written for non-8-bit bytes is incompatible with software written for 8-bit bytes, and vice versa. C and C++ code targeting non-8-bit bytes are incompatible dialects of C and C++.</p>
   <p><a href="https://en.wikipedia.org/wiki/POSIX#POSIX-certified">Wikipedia quotes</a> the following operating systems as being currently POSIX compliant (and therefore supporting 8-bit bytes):</p>
   <ul>
    <li data-md>
     <p>AIX</p>
    <li data-md>
     <p>HP-UX</p>
    <li data-md>
     <p>INTEGRITY</p>
    <li data-md>
     <p>macOS</p>
    <li data-md>
     <p>OpenServer</p>
    <li data-md>
     <p>UnixWare</p>
    <li data-md>
     <p>VxWorks</p>
    <li data-md>
     <p>z/OS</p>
   </ul>
   <p>And many others as being formerly compliant, or mostly compliant.</p>
   <p>Even StackOverflow, the pre-AI repository of our best knowledge (after Wikipedia), <a href="https://stackoverflow.com/questions/2098149/what-platforms-have-something-other-than-8-bit-char">gushes with enthusiasm about non-8-bit byte architectures</a>, and asks <a href="https://stackoverflow.com/questions/6971886/exotic-architectures-the-standards-committees-care-about">which exotic architecture the committee cares about</a>.</p>
   <p>This paper cannot succeed without mentioning the PDP-10 (though noting that PDP-11 has 8-bit bytes), and the fact that some DSPs have 16-bit, 24-bit, or 32-bit words treated as "bytes." These architectures made sense in their era, where word sizes varied and the notion of a byte wasn’t standardized. Today, nearly every general-purpose and embedded system adheres to the 8-bit byte model. The question isn’t whether there are still architectures where bytes aren’t 8-bits (there are!) but whether these care about modern C++... and whether modern C++ cares about them.</p>
   <p>The example which seems the most relevant of current architecture with non-8-bit-bytes is TI’s TMS320C28x, whose <a href="https://www.ti.com/lit/ug/spru514z/spru514z.pdf">compiler manual</a> states:</p>
   <blockquote> The TI compiler accepts C and C++ code conforming to the International Organization for Standardization (ISO)
standards for these languages. The compiler supports the 1989, 1999, and 2011 versions of the C language and
the 2003 version of the C++ language. </blockquote>
   <p><a href="https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1340214/tms320f28p650dk-compiler-with-c-11-support">TI has expressed that it does not intend to support C++11 or later</a>. They offer a <a href="https://qeeniu.net/lit/an/sprad88a/sprad88a.pdf?ts=1712908769025">migration guide from 8-bit bytes</a>.</p>
   <p>Another recent DSP which is sometimes brought up is CEVA-TeakLite. The latest generation, <a href="https://www.ceva-ip.com/wp-content/uploads/2017/02/CEVA-TeakLite-4-DSP-Family.pdf">CEVA-TeakLite-4, only supports a C compiler</a>.</p>
   <p>Yet another potentially relevant architecture is SHARC, whose <a href="https://www.analog.com/media/en/dsp-documentation/software-manuals/cces-sharccompiler-manual.pdf">latest compiler manual</a> explains which architectures support different architectural features in section "Processor Features", and whether the compiler option <code class="highlight"><c- o>-</c-><c- b>char</c-><c- o>-</c-><c- n>size</c-><c- p>[</c-><c- mi>-8</c-><c- o>|</c-><c- mi>-32</c-><c- p>]</c-></code> is available. In any case, only C++03 and C++11 are supported, with significant features missing (but interesting anachronisms can be enabled, I recommend reading that section of the manual!).</p>
   <p>A popular DSP which supports 8-bit bytes is <a href="https://www.cadence.com/content/dam/cadence-www/global/en_US/documents/tools/silicon-solutions/compute-ip/sw-dev-wp.pdf">Tensilica, whose compiler is based on clang</a>.</p>
   <p>Qualcomm provides three compilers that target their Kalimba series of DSPs. The <code class="highlight"><c- n>kcc</c-></code>, <code class="highlight"><c- n>kalcc</c-></code>, and <code class="highlight"><c- n>kalcc32</c-></code> compilers all appear to be C compilers with no support for C++. These compilers support a 24 bit byte size according to Coverity’s configuration, no public documentation seems available to confirm this.</p>
   <p>An EDG representative has privately stated:</p>
   <blockquote>I checked the configuration files that our customers share with us. One customer shared a configuration file that sets bytes to 32 as recently as 2022. This would configure a front end that supports C++17 and some C++20.</blockquote>
   <p>The author would happily retract this papers or change the proposal if hardware implementors expressed a desire to support modern C++ on their non-8-bit-per-byte hardware.</p>
   <p>Does this proposal prevent new weird architectures from being created? Not really! These hypothetical new architectures would write their entire software stack from scratch with or without this paper, and would benefit from C23’s <code class="highlight"><c- b>_BitInt</c-></code> as standardized by <a data-link-type="biblio" href="#biblio-n2763" title="Adding a Fundamental Type for N-bit integers">[N2763]</a> rather than have <code class="highlight"><c- b>char</c-></code> and other types of implicit size.</p>
   <h2 class="heading settled" data-level="3" id="yay"><span class="secno">3. </span><span class="content">Motivation</span><a class="self-link" href="#yay"></a></h2>
   <p>Why bother? A few reasons:</p>
   <ul>
    <li data-md>
     <p>The complexity of supporting non-8-bit byte architectures sprinkles small but unnecessary burden in quite a few parts of language and library (see below);</p>
    <li data-md>
     <p>Compilers and toolchains are required to support edge cases that do not reflect modern usage;</p>
    <li data-md>
     <p>New programmers are easily confused and find C++'s exotic tastes obtuse;</p>
    <li data-md>
     <p>Some seasoned programmers joyfully spend time supporting non-existent platforms "for portability" if they are unwise, even writing <a href="https://isocpp.org/wiki/faq/intrinsic-types#bits-per-byte">FAQs about this</a> which others then read and preach as gospel;</p>
    <li data-md>
     <p><a href="https://x.com/SebAaltonen/status/1843630586063413672">Our language looks silly</a>, solving problems that nobody has.</p>
   </ul>
   <p>One reason not to bother: there still are processors with non-8-bit bytes. The question facing us is: are they relevant to modern C++? If we keep supporting the current approach where Bytes"R"Us, will developers who use these processors use the new versions of C++?</p>
   <p>A cut-the-baby-in-half alternative is to mandate that <code class="highlight"><c- n>CHAR_BIT</c-> <c- o>%</c-> <c- mi>8</c-> <c- o>==</c-> <c- mi>0</c-></code>. Is that even making anything better? Only if the Committee decides to keep supporting Digital Signal Processors (DSPs) and other processors where <code class="highlight"><c- n>CHAR_BIT</c-></code> is not <code class="highlight"><c- mi>8</c-></code> but is a multiple of <code class="highlight"><c- mi>8</c-></code>.</p>
   <p>Another way to cut-the-baby-in-half is to mandate that <code class="highlight"><c- n>CHAR_BIT</c-></code> be <code class="highlight"><c- mi>8</c-></code> on hosted implementations, and leave implementation freedom on freestanding implementations.</p>
   <p>Regarding complexity, some committee members have been convinced by arguments such as:</p>
   <ul>
    <li data-md>
     <p>How can one write a truly portable serialization / deserialization library if the number of bits per bytes aren’t known?</p>
    <li data-md>
     <p>Networking mandates octets, specifying anything networking related (as the committee is currently doing with <a data-link-type="biblio" href="#biblio-p3482r0" title="Proposed API for creating TAPS based networking connections">[P3482R0]</a> and <a data-link-type="biblio" href="#biblio-p3185r0" title="A proposed direction for C++ Standard Networking based on IETF TAPS">[P3185R0]</a>) without bytes being 8 bits is difficult.</p>
    <li data-md>
     <p>The Unicode working group has spent significant time discussing UTF-8 on non-8-bit-bytes architectures, without satisfying results.</p>
    <li data-md>
     <p>How do <code class="highlight"><c- n>fread</c-></code> and <code class="highlight"><c- n>fwrite</c-></code> work? For example, how does one handle a file which starts with <code class="highlight"><c- n>FF</c-> <c- n>D8</c-> <c- n>FF</c-> <c- n>E0</c-></code> when bytes aren’t 8 bits?</p>
    <li data-md>
     <p>Modern cryptographic algorithm and the libraries implementing them assume bytes are 8 bits, meaning that cryptography is difficult to support on other machines. The same applies to modern compression.</p>
   </ul>
   <p>Overall, the members who brought these concerns seem to agree that architectures with non-8-bit-bytes are a language variant of C++, for which completely different code needs to be written. Combine this with hardware vendors expressing that they will not update the version of C++ that they support, and we conclude that the committee is maintaining a dead language variant.</p>
   <h2 class="heading settled" data-level="4" id="c"><span class="secno">4. </span><span class="content">Impact on C</span><a class="self-link" href="#c"></a></h2>
   <p>This proposal explores whether C++ is relevant to architectures where bytes are not 8 bits, and whether these architectures are relevant to C++. The C committee might reach a different conclusion with respect to this language. Ideally, both committees would be aligned. This papers therefore defers to WG14 and the SG22 liaison group to inform WG21.</p>
   <h2 class="heading settled" data-level="5" id="thereareotherlanguages"><span class="secno">5. </span><span class="content">Other languages</span><a class="self-link" href="#thereareotherlanguages"></a></h2>
   <p>Information on other languages:</p>
   <ul>
    <li data-md>
     <p><a href="https://docs.oracle.com/javase/specs/jvms/se6/html/Overview.doc.html">Java’s virtual machine specification</a> states "<code class="highlight"><c- n>byte</c-></code>, whose values are 8-bit signed two’s-complement integers".</p>
    <li data-md>
     <p>Rust <a href="https://doc.rust-lang.org/std/#primitives">primitive types</a> only contain <code class="highlight"><c- n>u8</c-></code>, and since Rust is implemented with LLVM it can only support 8-bit bytes.</p>
    <li data-md>
     <p>Python <a href="https://docs.python.org/3/library/stdtypes.html#bytes"><code class="highlight"><c- n>bytes</c-></code></a> are restricted to values in <code class="highlight"><c- p>[</c-><c- mi>0</c-><c- p>,</c-> <c- mi>256</c-><c- p>)</c-></code>.</p>
    <li data-md>
     <p>C# <a href="https://learn.microsoft.com/en-us/dotnet/api/system.byte?view=net-9.0"><code class="highlight"><c- n>System</c-><c- p>.</c-><c- n>Byte</c-></code></a> represents an 8-bit unsigned integer.</p>
    <li data-md>
     <p>Swift <a href="https://developer.apple.com/documentation/swift/special-use-numeric-types">special use numeric types</a> only contain <code class="highlight"><c- n>UInt8</c-></code>, and since Swift is implemented with LLVM it can only support 8-bit bytes.</p>
    <li data-md>
     <p>JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array">view using arrays</a> only support 8-bit bytes.</p>
    <li data-md>
     <p>Go’s <a href="https://go.dev/tour/basics/11">basic types</a> says "<code class="highlight"><c- n>byte</c-></code> // alias for <code class="highlight"><c- n>uint8</c-></code>".</p>
   </ul>
   <p>C and C++ feel smug.</p>
   <h2 class="heading settled" data-level="6" id="abiabiabi"><span class="secno">6. </span><span class="content">ABI Break! 💥</span><a class="self-link" href="#abiabiabi"></a></h2>
   <p>This paper mandates that bytes be 8 bits, and mandates that the <code class="highlight"><em><c- p>[</c-><c- n>u</c-><c- p>]</c-></em><c- n>int</c-><em><c- n>N</c-></em><c- n>_t</c-></code> typedefs from <code class="highlight"><c- n>cstdint</c-></code> no longer be optional.</p>
   <blockquote>
    <p style="font-family: &apos;Comic Sans MS&apos;, &apos;Comic Sans&apos;, cursive">But, this is an <em>ABI break</em>!!! 😱 </p>
    <p style="text-align: center">— the sentence that has ended countless C++ committee papers <small>(see <a data-link-type="biblio" href="#biblio-p2137r0" title="Goals and priorities for C++">[P2137r0]</a>)</small> </p>
   </blockquote>
   <p>Readers who’ve made it thus far will <em>love</em> this puzzle, and should take a short break from reading the paper to consider "wut? how? an abi, in <em>my</em> bytes???". Go on, try to find the break!</p>
   <p style="text-align: center">&lt;intermission> </p>
   <p>Do you see it yet?</p>
   <p>If you think "ah! Imagine an implementation where <code class="highlight"><c- b>short</c-></code> was 32 bits and <code class="highlight"><em><c- p>[</c-><c- n>u</c-><c- p>]</c-></em><c- b>int16_t</c-></code> was not defined! Then it would need to define <code class="highlight"><em><c- p>[</c-><c- n>u</c-><c- p>]</c-></em><c- b>int16_t</c-></code> and would thus need to make <code class="highlight"><c- b>short</c-></code> 16 bits.". Then you are indeed clever... but wrong! Because such an implementation could keep its <code class="highlight"><c- b>short</c-></code>s and make <code class="highlight"><em><c- p>[</c-><c- n>u</c-><c- p>]</c-></em><c- b>int16_t</c-></code> an <em>extended integer types</em> from [<strong>basic.fundamental</strong>]. You fell victim to one of the classic blunders! The most famous of which is, <em>'never get involved in a wording argument with Core,'</em> but only slightly less well-known is this: <em>'Never go in against a Standards Pedant when a paper’s death is on the line!'</em>.</p>
   <p>Any more educated guesses?</p>
   <p style="text-align: center">&lt;intermission> </p>
   <p>Alright clever reader, consider C23’s <code class="highlight"><c- n>stdint</c-><c- p>.</c-><c- n>h</c-></code>, section <strong>Minimum-width integer types</strong>, which states:</p>
   <blockquote>
     The typedef name <code class="highlight"><c- n>int_least</c-><em><c- n>N</c-></em><c- n>_t</c-></code> designates a signed integer type with a width of at least <em>N</em>, such that no signed integer type with lesser size has at least the specified width. Thus, <code class="highlight"><c- b>int_least32_t</c-></code> denotes a signed integer type with a width of at least 32 bits. 
    <p>The typedef name <code class="highlight"><c- n>uint_least</c-><em><c- n>N</c-></em><c- n>_t</c-></code> designates an unsigned integer type with a width of at least <em>N</em>, such that no unsigned integer type with lesser size has at least the specified width. Thus, <code class="highlight"><c- b>uint_least16_t</c-></code> denotes an unsigned integer type with a width of at least 16 bits.</p>
    <p>If the typedef name int<em>N</em>_t is defined, <code class="highlight"><c- n>int_least</c-><em><c- n>N</c-></em><c- n>_t</c-></code> designates the same type. If the typedef name uint<em>N</em>_t is defined, <code class="highlight"><c- n>uint_least</c-><em><c- n>N</c-></em><c- n>_t</c-></code> designates the same type.</p>
   </blockquote>
   <p>Imagine a platform where <code class="highlight"><c- b>short</c-></code> is greater than 16 bits, and where <code class="highlight"><c- b>int_least16_t</c-></code> is <code class="highlight"><c- b>short</c-></code> (thus, greater than 16 bits, let’s call them <em>jorts</em>), and which did not define <code class="highlight"><c- b>int16_t</c-></code>. Such a platform would see an ABI break because it now needs to define an exact-width type <code class="highlight"><c- b>int16_t</c-></code>, and therefore per C23 minimum-width integer type rules needs to change <code class="highlight"><c- b>int_least16_t</c-></code> since <code class="highlight"><c- b>int16_t</c-></code> now exists. Such a platform must either change the width of <code class="highlight"><c- b>short</c-></code> (a <strong>huge</strong> ABI break), or define <code class="highlight"><c- b>int_least16_t</c-></code> to be an extended integer type (thus, no longer <code class="highlight"><c- b>short</c-></code>). The latter is arguably an ABI break, albeit a tiny one because who uses <code class="highlight"><c- b>int_least16_t</c-></code>?</p>
   <p class="shaking" style="text-align: center">game over </p>
   <p>...or is it?</p>
   <p>Well, does such a platform, one with <em>jorts</em>, exist? The author cannot find evidence of such a platform, or equivalently odd platforms (say, with questionable choices for <code class="highlight"><c- b>int</c-></code>). Is lack of evidence proof? No, but here is what information exists:</p>
   <ul>
    <li data-md>
     <p>GCC <a href="https://github.com/gcc-mirror/gcc/blob/e7380688fa5917011c3fb85b5e06fb00f776a95d/gcc/c-family/c-common.cc#L5456">defines macros for exact width types</a> and has <a href="https://github.com/search?q=repo%3Agcc-mirror%2Fgcc+__INT16_TYPE__+path%3A%22gcc%2F%22&amp;type=code">extensive per-platform tests of its value</a>.</p>
    <li data-md>
     <p>LLVM also has <a href="https://github.com/search?q=repo%3Allvm%2Fllvm-project+%22define+__INT16_TYPE__%22+path%3A%22clang%2Ftest%22&amp;type=code">extensive tests on the underlying type representing <code class="highlight"><c- b>int16_t</c-></code></a>, and <a href="https://github.com/search?q=repo%3Allvm%2Fllvm-project+%22define __UINT16_MAX__%22+path%3A%22clang%2Ftest%22&amp;type=code">the size of this type</a>.</p>
   </ul>
   <p>One can perform the same searches for 32- and 64-bit integer types. The hypothetical ABI break relies on a hypothetical platform with surprising integer types which we will henceforth call <em>int-bozons</em> (drop the <em>N</em> to obtain <em>int-bozos</em>). Were someone to observe an ABI break, which we hope will not require a superconducting super collider, then this paper should be revisited, and the severity of the discovery examined.</p>
   <p>Clever readers of the evidence will have noticed an oddity... the <a href="https://www.microchip.com/en-us/products/microcontrollers-and-microprocessors/8-bit-mcus/avr-mcus">AVR</a> microcontroller sets <code class="highlight"><c- b>int16_t</c-></code> to <code class="highlight"><c- b>int</c-></code>! Why yes indeed. Isn’t this paper an ABI break for AVR? No, because on AVR, <code class="highlight"><c- k>sizeof</c-> <c- b>int</c-></code> is <code class="highlight"><c- mi>2</c-></code>. A fun archeological dig will uncover <a href="https://reviews.llvm.org/D100701">an LLVM review</a> which attempts to fix AVR to match the GCC definition, because LLVM used to define <code class="highlight"><c- b>int16_t</c-></code> to <code class="highlight"><c- b>short</c-></code> and GCC defined it to <code class="highlight"><c- b>int</c-></code> (the <a href="https://reviews.llvm.org/D102547">actual fix came in a separate commit</a>). The patch explains that the LLVM and GCC ABIs don’t match, and thereby <em>breaks the LLVM ABI to match the GCC one</em>. Imagine that, a compiler <em>breaking ABI</em>. 2021 was a wild year.</p>
   <p>The paper therefore concludes that questions of ABI breakage are put to rest for the purpose of this paper.</p>
   <h2 class="heading settled" data-level="7" id="lolno"><span class="secno">7. </span><span class="content"><code class="highlight"><c- b>short</c-></code> is 16, <code class="highlight"><c- b>int</c-></code> is 32, and more changes</span><a class="self-link" href="#lolno"></a></h2>
   <p>This is already a long paper, but some readers have asked and the paper must therefore answer:</p>
   <blockquote>Could we make <code class="highlight"><c- b>short</c-></code> 16 bits, <code class="highlight"><c- b>int</c-></code> 32 bits, etc? After all, we are making <code class="highlight"><c- b>char</c-></code> 8 bits!</blockquote>
   <p>Well, no. As we just re-discovered above, we cannot have nice things because doing the suggested change would be an <strong>ABI break</strong> for AVR. Do we want to do an ABI breaks? No, we’d never do such a thing.</p>
   <p>Could we just make <code class="highlight"><c- b>short</c-></code> 16 bits? To quote Sir Lancelot: "No, it’s too perilous."</p>
   <p>This paper therefore does not propose further changes. Motivated individuals, Sirs Galahads of sorts, are welcome to write a proposal, or file angry NB comments demanding change to <code class="highlight"><c- b>short</c-></code>, <code class="highlight"><c- b>int</c-></code>, and others. They might justify themselves with "Look, it’s my duty as a knight to sample as much peril as I can," and the author would not begrudge them. However, for the purpose of this paper, we’ve got to find the Holy Grail (there are exactly 8 bits in a byte). Come on.</p>
   <h2 class="heading settled" data-level="8" id="word"><span class="secno">8. </span><span class="content">Wording</span><a class="self-link" href="#word"></a></h2>
   <h3 class="heading settled" data-level="8.1" id="lang-word"><span class="secno">8.1. </span><span class="content">Language</span><a class="self-link" href="#lang-word"></a></h3>
   <p>Edit [<strong>intro.memory</strong>] as follows:</p>
   <blockquote>
     The fundamental storage unit in the C++ memory model is the <em>byte</em>
    <ins>, which is a contiguous sequence of 8 bits</ins>
    . 
    <del>A byte is at least large enough to contain the ordinary literal encoding of any element of the basic character set and the eight-bit code units of the Unicode UTF-8 encoding form and is composed of a contiguous sequence of bits, the number of which is implementation defined. </del>
    The memory available to C++ program consists of one or more sequences of contiguous bytes. Every byte has a unique address. 
    <p>
     <del> [ <em>Note:</em> The number of bits in a byte is reported by the macro <code class="highlight"><c- n>CHAR_BIT</c-></code> in the header <code class="highlight"><c- n>climits</c-></code>. — <em>end note</em> ] </del>
    </p>
    <p>
     <ins> [ <em>Note:</em> A byte is at least large enough to contain the ordinary literal encoding of any element of the basic character set and the eight-bit code units of the Unicode UTF-8 encoding form. — <em>end note</em> ] </ins>
    </p>
   </blockquote>
   <p>Edit [<strong>basic.fundamental</strong>] as follows:</p>
   <blockquote>
    <p>
     Table � — 
     <del>Minimum width</del>
     <ins>Width</ins>
      [<strong>basic.fundamental.width</strong>]
    </p>
    <table>
     <thead>
      <tr>
       <td>Type
       <td>
        <del>Minimum width</del>
        <ins>Width</ins>
         <em>N</em>
     <tbody>
      <tr>
       <td><code class="highlight"><c- b>signed</c-> <c- b>char</c-></code>
       <td>8
      <tr>
       <td><code class="highlight"><c- b>short</c-> <c- b>int</c-></code>
       <td>
        <ins>at least </ins>
        16
      <tr>
       <td><code class="highlight"><c- b>int</c-></code>
       <td>
        <ins>at least </ins>
        16
      <tr>
       <td><code class="highlight"><c- b>long</c-> <c- b>int</c-></code>
       <td>
        <ins>at least </ins>
        32
      <tr>
       <td><code class="highlight"><c- b>long</c-> <c- b>long</c-> <c- b>int</c-></code>
       <td>
        <ins>at least </ins>
        64
    </table>
    <p>
     The width of each standard signed integer type shall
     <del> not be less than</del>
     <ins> match</ins>
      the values specified in [<strong>basic.fundamental.width</strong>]. The value representation of a signed or unsigned integer type comprises <em>N</em> bits, where N is the respective width. Each set of values for any padding bits [<strong>basic.types.general</strong>] in the object representation are alternative representations of the value specified by the value representation.
    </p>
    <p>Except as specified above, the width of a signed or unsigned integer type is implementation-defined.</p>
   </blockquote>
   <p>Edit the example at the end of [<strong>dcl.init.list</strong>] as follows:</p>
   <blockquote>
<pre class="highlight"><code><c- b>int</c-> <c- n>x</c-> <c- o>=</c-> <c- mi>999</c-><c- p>;</c->                    <c- c1>// x is not a constant expression</c->
<c- k>const</c-> <c- b>int</c-> <c- n>y</c-> <c- o>=</c-> <c- mi>999</c-><c- p>;</c->
<c- k>const</c-> <c- b>int</c-> <c- n>z</c-> <c- o>=</c-> <c- mi>99</c-><c- p>;</c->
<c- b>char</c-> <c- n>c1</c-> <c- o>=</c-> <c- n>x</c-><c- p>;</c->                    <c- c1>// OK, though it potentially narrows (in this case, it does narrow)</c->
<c- b>char</c-> <c- n>c2</c-><c- p>{</c-><c- n>x</c-><c- p>};</c->                     <c- c1>// error: potentially narrows</c->
<c- b>char</c-> <c- n>c3</c-><c- p>{</c-><c- n>y</c-><c- p>};</c->                     <c- c1>// error: narrows</c-><del><c- c1> (assuming char is 8 bits)</c-></del>
<c- b>char</c-> <c- n>c4</c-><c- p>{</c-><c- n>z</c-><c- p>};</c->                     <c- c1>// OK, no narrowing needed</c->
<c- b>unsigned</c-> <c- b>char</c-> <c- n>uc1</c-> <c- o>=</c-> <c- p>{</c-><c- mi>5</c-><c- p>};</c->        <c- c1>// OK, no narrowing needed</c->
<c- b>unsigned</c-> <c- b>char</c-> <c- n>uc2</c-> <c- o>=</c-> <c- p>{</c-><c- mi>-1</c-><c- p>};</c->       <c- c1>// error: narrows</c->
<c- b>unsigned</c-> <c- b>int</c-> <c- n>ui1</c-> <c- o>=</c-> <c- p>{</c-><c- mi>-1</c-><c- p>};</c->        <c- c1>// error: narrows</c->
<c- b>signed</c-> <c- b>int</c-> <c- n>si1</c-> <c- o>=</c->
  <c- p>{</c-> <c- p>(</c-><c- b>unsigned</c-> <c- b>int</c-><c- p>)</c-><c- mi>-1</c-> <c- p>};</c->         <c- c1>// error: narrows</c->
<c- b>int</c-> <c- n>ii</c-> <c- o>=</c-> <c- p>{</c-><c- mf>2.0</c-><c- p>};</c->                 <c- c1>// error: narrows</c->
<c- b>float</c-> <c- n>f1</c-> <c- p>{</c-> <c- n>x</c-> <c- p>};</c->                 <c- c1>// error: potentially narrows</c->
<c- b>float</c-> <c- n>f2</c-> <c- p>{</c-> <c- mi>7</c-> <c- p>};</c->                 <c- c1>// OK, 7 can be exactly represented as a float</c->
<c- b>bool</c-> <c- n>b</c-> <c- o>=</c-> <c- p>{</c-><c- s>"meow"</c-><c- p>};</c->              <c- c1>// error: narrows</c->
<c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->
<c- b>int</c-> <c- n>a</c-><c- p>[]</c-> <c- o>=</c-> <c- p>{</c-> <c- mi>2</c-><c- p>,</c-> <c- n>f</c-><c- p>(</c-><c- mi>2</c-><c- p>),</c-> <c- n>f</c-><c- p>(</c-><c- mf>2.0</c-><c- p>)</c-> <c- p>};</c->  <c- c1>// OK, the double-to-int conversion is not at the top level</c->
</code></pre>
   </blockquote>
   <h3 class="heading settled" data-level="8.2" id="lib-word"><span class="secno">8.2. </span><span class="content">Library</span><a class="self-link" href="#lib-word"></a></h3>
   <p>Edit [<strong>climits.syn</strong>] as follows:</p>
   <blockquote>
<pre class="highlight"><code><c- c1>// all freestanding</c->
<c- cp>#define CHAR_BIT </c-><del><c- cp>see below</c-></del><ins><c- cp>8</c-></ins>
<c- cp>#define SCHAR_MIN </c-><del><c- cp>see below</c-></del><ins><c- cp>-128</c-></ins>
<c- cp>#define SCHAR_MAX </c-><del><c- cp>see below</c-></del><ins><c- cp>127</c-></ins>
<c- cp>#define UCHAR_MAX </c-><del><c- cp>see below</c-></del><ins><c- cp>255</c-></ins>
<c- cp>#define CHAR_MIN see below</c->
<c- cp>#define CHAR_MAX see below</c->
<c- cp>#define MB_LEN_MAX see below</c->
<c- cp>#define SHRT_MIN see below</c->
<c- cp>#define SHRT_MAX see below</c->
<c- cp>#define USHRT_MAX see below</c->
<c- cp>#define INT_MIN see below</c->
<c- cp>#define INT_MAX see below</c->
<c- cp>#define UINT_MAX see below</c->
<c- cp>#define LONG_MIN see below</c->
<c- cp>#define LONG_MAX see below</c->
<c- cp>#define ULONG_MAX see below</c->
<c- cp>#define LLONG_MIN see below</c->
<c- cp>#define LLONG_MAX see below</c->
<c- cp>#define ULLONG_MAX see below</c->
</code></pre>
    <p>
     The header <code class="highlight"><c- n>climits</c-></code> defines all macros the same as the C standard library header <code class="highlight"><c- n>limits</c-><c- p>.</c-><c- n>h</c-></code>
     <ins>, except as noted above</ins>
     .
    </p>
    <blockquote> Except for <code class="highlight"><c- n>CHAR_BIT</c-></code> and <code class="highlight"><c- n>MB_LEN_MAX</c-></code>, a macro referring to an integer type <code class="highlight"><c- n>T</c-></code> defines a constant whose type is the promoted type of <code class="highlight"><c- n>T</c-></code>. </blockquote>
   </blockquote>
   <p>Edit [<strong>cstdint.syn</strong>] as follows:</p>
   <blockquote>
     The header <code class="highlight"><c- n>cstdint</c-></code> supplies integer types having specified widths, and macros that specify limits of integer types. 
<pre class="highlight"><code><c- b>int8_t</c->
<c- b>int16_t</c->
<c- b>int32_t</c->
<c- b>int64_t</c->
<c- b>int_fast8_t</c->
<c- b>int_fast16_t</c->
<c- b>int_fast32_t</c->
<c- b>int_fast64_t</c->
<c- b>int_least8_t</c->
<c- b>int_least16_t</c->
<c- b>int_least32_t</c->
<c- b>int_least64_t</c->
<c- b>intmax_t</c->
<c- b>intptr_t</c->
<c- b>uint8_t</c->
<c- b>uint16_t</c->
<c- b>uint32_t</c->
<c- b>uint64_t</c->
<c- b>uint_fast8_t</c->
<c- b>uint_fast16_t</c->
<c- b>uint_fast32_t</c->
<c- b>uint_fast64_t</c->
<c- b>uint_least8_t</c->
<c- b>uint_least16_t</c->
<c- b>uint_least32_t</c->
<c- b>uint_least64_t</c->
<c- b>uintmax_t</c->
<c- b>uintptr_t</c->
<c- n>INTN_MIN</c->
<c- n>INTN_MAX</c->
<c- n>UINTN_MAX</c->
<c- n>INT_FASTN_MIN</c->
<c- n>INT_FASTN_MAX</c->
<c- n>UINT_FASTN_MAX</c->
<c- n>INT_LEASTN_MIN</c->
<c- n>INT_LEASTN_MAX</c->
<c- n>UINT_LEASTN_MAX</c->
<c- n>INTMAX_MIN</c->
<c- n>INTMAX_MAX</c->
<c- n>UINTMAX_MAX</c->
<c- n>INTPTR_MIN</c->
<c- n>INTPTR_MAX</c->
<c- n>UINTPTR_MAX</c->
<c- n>PTRDIFF_MIN</c->
<c- n>PTRDIFF_MAX</c->
<c- n>SIZE_MAX</c->
<c- n>SIG_ATOMIC_MIN</c->
<c- n>SIG_ATOMIC_MAX</c->
<c- n>WCHAR_MAX</c->
<c- n>WCHAR_MIN</c->
<c- n>WINT_MIN</c->
<c- n>WINT_MAX</c->
<c- n>INTN_C</c->
<c- n>UINTN_C</c->
<c- n>INTMAX_C</c->
<c- n>UINTMAX_C</c->
</code></pre>
<pre class="highlight"><code><c- c1>// all freestanding</c->
<c- k>namespace</c-> <c- nn>std</c-> <c- p>{</c->
  <c- k>using</c-> <c- b>int8_t</c->         <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del>   <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- b>int16_t</c->        <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del>   <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- b>int32_t</c->        <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del>   <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- b>int64_t</c->        <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del>   <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- n>int</c-><i><c- n>N</c-></i><c- n>_t</c->         <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->             <c- c1>// optional</c->

  <c- k>using</c-> <c- b>int_fast8_t</c->    <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>int_fast16_t</c->   <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>int_fast32_t</c->   <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>int_fast64_t</c->   <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- n>int_fast</c-><i><c- n>N</c-></i><c- n>_t</c->    <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->             <c- c1>// optional</c->

  <c- k>using</c-> <c- b>int_least8_t</c->   <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>int_least16_t</c->  <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>int_least32_t</c->  <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>int_least64_t</c->  <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- n>int_least</c-><i><c- n>N</c-></i><c- n>_t</c->   <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->             <c- c1>// optional</c->

  <c- k>using</c-> <c- b>intmax_t</c->       <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>intptr_t</c->       <c- o>=</c-> <i><c- b>signed</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->   <c- c1>// optional</c->

  <c- k>using</c-> <c- b>uint8_t</c->        <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del> <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- b>uint16_t</c->       <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del> <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- b>uint32_t</c->       <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del> <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- b>uint64_t</c->       <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-><del> <c- c1>// optional</c-></del>
  <c- k>using</c-> <c- n>uint</c-><i><c- n>N</c-></i><c- n>_t</c->        <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->             <c- c1>// optional</c->

  <c- k>using</c-> <c- b>uint_fast8_t</c->   <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uint_fast16_t</c->  <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uint_fast32_t</c->  <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uint_fast64_t</c->  <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- n>uint_fast</c-><i><c- n>N</c-></i><c- n>_t</c->   <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->             <c- c1>// optional</c->

  <c- k>using</c-> <c- b>uint_least8_t</c->  <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uint_least16_t</c-> <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uint_least32_t</c-> <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uint_least64_t</c-> <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- n>uint_least</c-><i><c- n>N</c-></i><c- n>_t</c->  <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->             <c- c1>// optional</c->

  <c- k>using</c-> <c- b>uintmax_t</c->      <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c->
  <c- k>using</c-> <c- b>uintptr_t</c->      <c- o>=</c-> <i><c- b>unsigned</c-> <c- n>integer</c-> <c- n>type</c-></i><c- p>;</c-> <c- c1>// optional</c->
<c- p>}</c->

<c- cp>#define INT</c-><i><c- cp>N</c-></i><c- cp>_MIN         </c-><i><c- cp>see below</c-></i>
<c- cp>#define INT</c-><i><c- cp>N</c-></i><c- cp>_MAX         </c-><i><c- cp>see below</c-></i>
<c- cp>#define UINT</c-><i><c- cp>N</c-></i><c- cp>_MAX        </c-><i><c- cp>see below</c-></i>

<c- cp>#define INT_FAST</c-><i><c- cp>N</c-></i><c- cp>_MIN    </c-><i><c- cp>see below</c-></i>
<c- cp>#define INT_FAST</c-><i><c- cp>N</c-></i><c- cp>_MAX    </c-><i><c- cp>see below</c-></i>
<c- cp>#define UINT_FAST</c-><i><c- cp>N</c-></i><c- cp>_MAX   </c-><i><c- cp>see below</c-></i>

<c- cp>#define INT_LEAST</c-><i><c- cp>N</c-></i><c- cp>_MIN   </c-><i><c- cp>see below</c-></i>
<c- cp>#define INT_LEAST</c-><i><c- cp>N</c-></i><c- cp>_MAX   </c-><i><c- cp>see below</c-></i>
<c- cp>#define UINT_LEAST</c-><i><c- cp>N</c-></i><c- cp>_MAX  </c-><i><c- cp>see below</c-></i>

<c- cp>#define INTMAX_MIN       </c-><i><c- cp>see below</c-></i>
<c- cp>#define INTMAX_MAX       </c-><i><c- cp>see below</c-></i>
<c- cp>#define UINTMAX_MAX      </c-><i><c- cp>see below</c-></i>

<c- cp>#define INTPTR_MIN       </c-><i><c- cp>see below</c-></i><c- cp>              </c-><c- c1>// optional</c->
<c- cp>#define INTPTR_MAX       </c-><i><c- cp>see below</c-></i><c- cp>              </c-><c- c1>// optional</c->
<c- cp>#define UINTPTR_MAX      </c-><i><c- cp>see below</c-></i><c- cp>              </c-><c- c1>// optional</c->

<c- cp>#define PTRDIFF_MIN      </c-><i><c- cp>see below</c-></i>
<c- cp>#define PTRDIFF_MAX      </c-><i><c- cp>see below</c-></i>
<c- cp>#define SIZE_MAX         </c-><i><c- cp>see below</c-></i>

<c- cp>#define SIG_ATOMIC_MIN   </c-><i><c- cp>see below</c-></i>
<c- cp>#define SIG_ATOMIC_MAX   </c-><i><c- cp>see below</c-></i>

<c- cp>#define WCHAR_MIN        </c-><i><c- cp>see below</c-></i>
<c- cp>#define WCHAR_MAX        </c-><i><c- cp>see below</c-></i>

<c- cp>#define WINT_MIN         </c-><i><c- cp>see below</c-></i>
<c- cp>#define WINT_MAX         </c-><i><c- cp>see below</c-></i>

<c- cp>#define INT</c-><i><c- cp>N</c-></i><c- cp>_C(value)    </c-><i><c- cp>see below</c-></i>
<c- cp>#define UINT</c-><i><c- cp>N</c-></i><c- cp>_C(value)   </c-><i><c- cp>see below</c-></i>
<c- cp>#define INTMAX_C(value)  </c-><i><c- cp>see below</c-></i>
<c- cp>#define UINTMAX_C(value) </c-><i><c- cp>see below</c-></i>
</code></pre>
    <p>
     The header defines all types and macros the same as the C standard library header <code class="highlight"><c- n>stdint</c-><c- p>.</c-><c- n>h</c-></code>
     <ins>, except that none of the types nor macros for <code class="highlight"><c- mi>8</c-></code>, <code class="highlight"><c- mi>16</c-></code>, <code class="highlight"><c- mi>32</c-></code>, nor <code class="highlight"><c- mi>64</c-></code> are optional</ins>
     .
    </p>
    <p>
     All types that use the placeholder <i>N</i> are optional when <i>N</i> is not <code class="highlight"><c- mi>8</c-></code>, <code class="highlight"><c- mi>16</c-></code>, <code class="highlight"><c- mi>32</c-></code>, or <code class="highlight"><c- mi>64</c-></code>. The exact-width types <code class="highlight"><c- n>int</c-><i><c- n>N</c-></i><c- n>_t</c-></code> and <code class="highlight"><c- n>uint</c-><i><c- n>N</c-></i><c- n>_t</c-></code> for <i>N</i> = <code class="highlight"><c- mi>8</c-></code>, <code class="highlight"><c- mi>16</c-></code>, <code class="highlight"><c- mi>32</c-></code>, and <code class="highlight"><c- mi>64</c-></code> 
     <del>are also optional; however, if an implementation defines integer types with the corresponding width and no padding bits, it defines the corresponding typedef-names. </del>
     <ins>may be aliases for the standard integer types [<strong>basic.fundamental</strong>], or the extended integer types [<strong>basic.fundamental</strong>].</ins>
     Each of the macros listed in this subclause is defined if and only if the implementation defines the corresponding typedef-name.
    </p>
    <blockquote> The macros <code class="highlight"><c- n>INT</c-><i><c- n>N</c-></i><c- n>_C</c-></code> and <code class="highlight"><c- n>UINT</c-><i><c- n>N</c-></i><c- n>_C</c-></code> correspond to the typedef-names <code class="highlight"><c- n>int_least</c-><i><c- n>N</c-></i><c- n>_t</c-></code> and <code class="highlight"><c- n>uint_least</c-><i><c- n>N</c-></i><c- n>_t</c-></code>, respectively. </blockquote>
   </blockquote>
   <p>Within [<strong>localization</strong>], remove the 4 <em>mandates</em> clauses specifying:</p>
   <blockquote>
    <del><code class="highlight"><c- n>CHAR_BIT</c-> <c- o>==</c-> <c- mi>8</c-></code> is <code class="highlight">true</code></del>
   </blockquote>
   <p>Within [<strong>cinttypes.syn</strong>], do not change the list of <code class="highlight"><c- n>PRI</c-></code> macros, and leave this paragraph as-is:</p>
   <blockquote> Each of the <code class="highlight"><c- n>PRI</c-></code> macros listed in this subclause is defined if and only if the implementation defines the corresponding <em>typedef-name</em> in [<strong>cstdint.syn</strong>]. Each of the <code class="highlight"><c- n>SCN</c-></code> macros listed in this subclause is defined if and only if the implementation defines the corresponding <em>typedef-name</em> in [[<strong>cstdint.syn</strong>]] and has a suitable <code class="highlight"><c- n>fscanf</c-></code> length modifier for the type. </blockquote>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

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

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

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

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

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

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


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

    tocNav.appendChild(toggle);
  }

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

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

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

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-n2763">[N2763]
   <dd>Aaron Ballman; et al. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2763.pdf"><cite>Adding a Fundamental Type for N-bit integers</cite></a>. 2021-06-21. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2763.pdf">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2763.pdf</a>
   <dt id="biblio-p0907r4">[P0907r4]
   <dd>JF Bastien. <a href="https://wg21.link/p0907r4"><cite>Signed Integers are Two’s Complement</cite></a>. 6 October 2018. URL: <a href="https://wg21.link/p0907r4">https://wg21.link/p0907r4</a>
   <dt id="biblio-p2137r0">[P2137r0]
   <dd>Chandler Carruth, Timothy Costa, Hal Finkel, Dmitri Gribenko, D. S. Hollman, Chris Kennelly, Thomas Köppe, Damien Lebrun-Grandie, Bryce Adelstein Lelbach, Josh Levenberg, Nevin Liber, Chris Palmer, Tom Scogland, Richard Smith, David Stone, Christian Trott, Titus Winters. <a href="https://wg21.link/p2137r0"><cite>Goals and priorities for C++</cite></a>. 2 March 2020. URL: <a href="https://wg21.link/p2137r0">https://wg21.link/p2137r0</a>
   <dt id="biblio-p3185r0">[P3185R0]
   <dd>Thomas Rodgers. <a href="https://wg21.link/p3185r0"><cite>A proposed direction for C++ Standard Networking based on IETF TAPS</cite></a>. 14 December 2024. URL: <a href="https://wg21.link/p3185r0">https://wg21.link/p3185r0</a>
   <dt id="biblio-p3477r0">[P3477R0]
   <dd>JF Bastien. <a href="https://wg21.link/p3477r0"><cite>There are exactly 8 bits in a byte</cite></a>. 16 October 2024. URL: <a href="https://wg21.link/p3477r0">https://wg21.link/p3477r0</a>
   <dt id="biblio-p3477r1">[P3477r1]
   <dd>JF Bastien. <a href="https://wg21.link/p3477r1"><cite>There are exactly 8 bits in a byte</cite></a>. 21 November 2024. URL: <a href="https://wg21.link/p3477r1">https://wg21.link/p3477r1</a>
   <dt id="biblio-p3482r0">[P3482R0]
   <dd>Thomas W Rodgers, Dietmar Kuhl. <a href="https://wg21.link/p3482r0"><cite>Proposed API for creating TAPS based networking connections</cite></a>. 14 December 2024. URL: <a href="https://wg21.link/p3482r0">https://wg21.link/p3482r0</a>
   <dt id="biblio-posix">[POSIX]
   <dd><a href="https://pubs.opengroup.org/onlinepubs/9799919799/"><cite>The Open Group Base Specifications Issue 8</cite></a>. 2024. URL: <a href="https://pubs.opengroup.org/onlinepubs/9799919799/">https://pubs.opengroup.org/onlinepubs/9799919799/</a>
  </dl>