<!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>p0907r0: Signed Integers are Two’s Complement</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
 *
 * 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)
 *   - .assertion  for assertions                    (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *
 * 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
 *
 * 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)
 *
 ******************************************************************************/

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

	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;

		/* Colors */
		color: black;
		background: white 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-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		color: white;
		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;
		border-color: #c00;
	}

	/* 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: 2;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
			color: black;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

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

			background: white;
			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;
			background: white;
		}
		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		#toc-nav > a:hover,
		#toc-nav > a:focus {
			background: #f8f8f8;
		}
		#toc-nav > a:not(:hover):not(:focus) {
			color: #707070;
		}

		/* 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-toggle-inline {
			vertical-align: 0.05em;
			font-size: 80%;
			color: gray;
			color: hsla(203,20%,40%,.7);
			border-style: none;
			background: transparent;
			position: relative;
		}
		#toc-toggle-inline:hover:not(:active),
		#toc-toggle-inline:focus:not(:active) {
			text-shadow: 1px 1px silver;
			top: -1px;
			left: -1px;
		}

		#toc-nav :active {
			color: #C00;
		}
	}

/** 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);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) 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);
		}
		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);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) 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);
		}

		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;
		background: transparent;
	}

	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,
	#subtitle {
		/* #subtitle 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) > hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		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;
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	  padding: .5em;
	  border: thin solid #ddd; 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: normal;
	}
	dfn var {
		font-style: normal;
	}

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

	del { color: red;  text-decoration: line-through; }
	ins { color: #080; text-decoration: underline;    }

/** 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;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	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;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #C00;
		border-color: #C00;
	}

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

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

	img {
		border-style: none;
	}

	/* 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;
	}
	.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 {
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}

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

	blockquote {
		border-color: silver;
	}

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

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* 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;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* 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;
		background: #E9FBE9;
		overflow: auto;
	}

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

	details.note > summary {
		display: block;
		color: hsl(120, 70%, 30%);
	}
	details.note[open] > summary {
		border-bottom: 1px silver solid;
	}

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

	.assertion {
		border-color: #AAA;
		background: #EEE;
	}

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

	.advisement {
		border-color: orange;
		border-style: none solid;
		background: #FFEECC;
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement > .marker {
		color: #B35F00;
	}

/** 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: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

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

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

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

	.def {
		padding: .5em 1em;
		background: #DEF;
		margin: 1.2em 0;
		border-left: 0.5em solid #8CCBF2;
	}

/******************************************************************************/
/*                                    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;
	}

	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-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;
		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;
		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-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.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;
		line-height: 1.1rem; /* consistent spacing */
	}

	/* 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%;    }

	.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%;
	}

	: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; }
	}
	@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; }
	}
	body.toc-sidebar #toc :not(li) > .toc              { margin-left:  4rem; }
	body.toc-sidebar #toc .toc .secno                  { margin-left: -4rem; }
	body.toc-sidebar #toc .toc > li li li              { margin-left:  1rem; }
	body.toc-sidebar #toc .toc > li li li .secno       { margin-left: -5rem; }
	body.toc-sidebar #toc .toc > li li li li .secno    { margin-left: -6rem; }
	body.toc-sidebar #toc .toc > li li li li li .secno { margin-left: -7rem; }

	.toc li {
		clear: both;
	}


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

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

/** 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]) {
		background: #f7f8f9;
	}

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

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

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

/******************************************************************************/
/*                                    Legacy                                  */
/******************************************************************************/

	/* This rule is inherited from past style sheets. No idea what it's for. */
	.hide { display: none }



/******************************************************************************/
/*                             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 > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-left: calc(13px + 26.5rem - 50vw);
			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-left: calc(40em - 50vw) !important;
			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-left: 0 !important;
			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>
  <meta content="Bikeshed version 39e591568007a470c8705dd14db3d9d86db98356" name="generator">
  <link href="http://wg21.link/P0907r0" rel="canonical">
<style>/* style-md-lists */

            /* This is a weird hack for me not yet following the commonmark spec
               regarding paragraph and lists. */
            [data-md] > :first-child {
                margin-top: 0;
            }
            [data-md] > :last-child {
                margin-bottom: 0;
            }</style>
<style>/* style-hidedel */

            #hidedel:checked ~ del, #hidedel:checked ~ * del { display:none; }
            #hidedel ~ #hidedel-label::before, #hidedel ~ * #hidedel-label::before { content: "☐ "; }
            #hidedel:checked ~ #hidedel-label::before, #hidedel:checked ~ * #hidedel-label::before { content: "☑ "; }
        </style>
<style>/* style-selflinks */

            .heading, .issue, .note, .example, li, dt {
                position: relative;
            }
            a.self-link {
                position: absolute;
                top: 0;
                left: calc(-1 * (3.5rem - 26px));
                width: calc(3.5rem - 26px);
                height: 2em;
                text-align: center;
                border: none;
                transition: opacity .2s;
                opacity: .5;
            }
            a.self-link:hover {
                opacity: 1;
            }
            .heading > a.self-link {
                font-size: 83%;
            }
            li > a.self-link {
                left: calc(-1 * (3.5rem - 26px) - 2em);
            }
            dfn > a.self-link {
                top: auto;
                left: auto;
                opacity: 0;
                width: 1.5em;
                height: 1.5em;
                background: gray;
                color: white;
                font-style: normal;
                transition: opacity .2s, background-color .2s, color .2s;
            }
            dfn:hover > a.self-link {
                opacity: 1;
            }
            dfn > a.self-link:hover {
                color: black;
            }

            a.self-link::before            { content: "¶"; }
            .heading > a.self-link::before { content: "§"; }
            dfn > a.self-link::before      { content: "#"; }</style>
<style>/* style-counters */

            body {
                counter-reset: example figure issue;
            }
            .issue {
                counter-increment: issue;
            }
            .issue:not(.no-marker)::before {
                content: "Issue " counter(issue);
            }

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

            figcaption {
                counter-increment: figure;
            }
            figcaption:not(.no-marker)::before {
                content: "Figure " counter(figure) " ";
            }</style>
<style>/* style-autolinks */

            .css.css, .property.property, .descriptor.descriptor {
                color: #005a9c;
                font-size: inherit;
                font-family: inherit;
            }
            .css::before, .property::before, .descriptor::before {
                content: "‘";
            }
            .css::after, .property::after, .descriptor::after {
                content: "’";
            }
            .property, .descriptor {
                /* Don't wrap property and descriptor names */
                white-space: nowrap;
            }
            .type { /* CSS value <type> */
                font-style: italic;
            }
            pre .property::before, pre .property::after {
                content: "";
            }
            [data-link-type="property"]::before,
            [data-link-type="propdesc"]::before,
            [data-link-type="descriptor"]::before,
            [data-link-type="value"]::before,
            [data-link-type="function"]::before,
            [data-link-type="at-rule"]::before,
            [data-link-type="selector"]::before,
            [data-link-type="maybe"]::before {
                content: "‘";
            }
            [data-link-type="property"]::after,
            [data-link-type="propdesc"]::after,
            [data-link-type="descriptor"]::after,
            [data-link-type="value"]::after,
            [data-link-type="function"]::after,
            [data-link-type="at-rule"]::after,
            [data-link-type="selector"]::after,
            [data-link-type="maybe"]::after {
                content: "’";
            }

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

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

            [data-link-type=biblio] {
                white-space: pre;
            }</style>
<style>/* style-syntax-highlighting */

        .highlight:not(.idl) { background: hsl(24, 20%, 95%); }
        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 .c { color: #708090 } /* Comment */
        .highlight .k { color: #990055 } /* Keyword */
        .highlight .l { color: #000000 } /* Literal */
        .highlight .n { color: #0077aa } /* Name */
        .highlight .o { color: #999999 } /* Operator */
        .highlight .p { color: #999999 } /* Punctuation */
        .highlight .cm { color: #708090 } /* Comment.Multiline */
        .highlight .cp { color: #708090 } /* Comment.Preproc */
        .highlight .c1 { color: #708090 } /* Comment.Single */
        .highlight .cs { color: #708090 } /* Comment.Special */
        .highlight .kc { color: #990055 } /* Keyword.Constant */
        .highlight .kd { color: #990055 } /* Keyword.Declaration */
        .highlight .kn { color: #990055 } /* Keyword.Namespace */
        .highlight .kp { color: #990055 } /* Keyword.Pseudo */
        .highlight .kr { color: #990055 } /* Keyword.Reserved */
        .highlight .kt { color: #990055 } /* Keyword.Type */
        .highlight .ld { color: #000000 } /* Literal.Date */
        .highlight .m { color: #000000 } /* Literal.Number */
        .highlight .s { color: #a67f59 } /* Literal.String */
        .highlight .na { color: #0077aa } /* Name.Attribute */
        .highlight .nc { color: #0077aa } /* Name.Class */
        .highlight .no { color: #0077aa } /* Name.Constant */
        .highlight .nd { color: #0077aa } /* Name.Decorator */
        .highlight .ni { color: #0077aa } /* Name.Entity */
        .highlight .ne { color: #0077aa } /* Name.Exception */
        .highlight .nf { color: #0077aa } /* Name.Function */
        .highlight .nl { color: #0077aa } /* Name.Label */
        .highlight .nn { color: #0077aa } /* Name.Namespace */
        .highlight .py { color: #0077aa } /* Name.Property */
        .highlight .nt { color: #669900 } /* Name.Tag */
        .highlight .nv { color: #222222 } /* Name.Variable */
        .highlight .ow { color: #999999 } /* Operator.Word */
        .highlight .mb { color: #000000 } /* Literal.Number.Bin */
        .highlight .mf { color: #000000 } /* Literal.Number.Float */
        .highlight .mh { color: #000000 } /* Literal.Number.Hex */
        .highlight .mi { color: #000000 } /* Literal.Number.Integer */
        .highlight .mo { color: #000000 } /* Literal.Number.Oct */
        .highlight .sb { color: #a67f59 } /* Literal.String.Backtick */
        .highlight .sc { color: #a67f59 } /* Literal.String.Char */
        .highlight .sd { color: #a67f59 } /* Literal.String.Doc */
        .highlight .s2 { color: #a67f59 } /* Literal.String.Double */
        .highlight .se { color: #a67f59 } /* Literal.String.Escape */
        .highlight .sh { color: #a67f59 } /* Literal.String.Heredoc */
        .highlight .si { color: #a67f59 } /* Literal.String.Interpol */
        .highlight .sx { color: #a67f59 } /* Literal.String.Other */
        .highlight .sr { color: #a67f59 } /* Literal.String.Regex */
        .highlight .s1 { color: #a67f59 } /* Literal.String.Single */
        .highlight .ss { color: #a67f59 } /* Literal.String.Symbol */
        .highlight .vc { color: #0077aa } /* Name.Variable.Class */
        .highlight .vg { color: #0077aa } /* Name.Variable.Global */
        .highlight .vi { color: #0077aa } /* Name.Variable.Instance */
        .highlight .il { color: #000000 } /* Literal.Number.Integer.Long */
        </style>
 <body class="h-entry">
  <input id="hidedel" style="display:none" type="checkbox">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">p0907r0<br>Signed Integers are Two’s Complement</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2018-02-09">9 February 2018</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="http://wg21.link/P0907r0">http://wg21.link/P0907r0</a>
     <dt>Author:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:jfbastien@apple.com">JF Bastien</a> (<span class="p-org org">Apple</span>)
     <dt>Audience:
     <dd>EWG, SG12
     <dt>Toggle Diffs:
     <dd>
      <label for="hidedel" id="hidedel-label">Hide deleted text</label>
     <dt>Project:
     <dd><span>ISO JTC1/SC22/WG21: Programming Language C++</span>
     <dt>Source:
     <dd><span><a href="https://github.com/jfbastien/papers/blob/master/source/P0907r0.bs">github.com/jfbastien/papers/blob/master/source/P0907r0.bs</a></span>
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>There is One True Representation for signed integers, and that representation is two’s complement.</p>
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#intro"><span class="secno">1</span> <span class="content">Introduction</span></a>
    <li><a href="#word"><span class="secno">2</span> <span class="content">Proposed Wording</span></a>
    <li><a href="#scope"><span class="secno">3</span> <span class="content">Out of Scope</span></a>
    <li><a href="#c-sign"><span class="secno">4</span> <span class="content">C Signed Integer Wording</span></a>
    <li><a href="#survey"><span class="secno">5</span> <span class="content">Survey of Signed Integer Representations</span></a>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="intro"><span class="secno">1. </span><span class="content">Introduction</span><a class="self-link" href="#intro"></a></h2>
   <p><a data-link-type="biblio" href="#biblio-c11">[C11]</a> Integer types allows three representations for signed integral types:</p>
   <ul>
    <li data-md="">
     <p>Signed magnitude</p>
    <li data-md="">
     <p>Ones' complement</p>
    <li data-md="">
     <p>Two’s complement</p>
   </ul>
   <p>See <a href="#c-sign">§4 C Signed Integer Wording</a> for full wording.</p>
   <p>C++ inherits these three signed integer representations from C. To the author’s
knowledge no modern machine uses both C++ and a signed integer representation
other than two’s complement (see <a href="#survey">§5 Survey of Signed Integer Representations</a>). None of <a data-link-type="biblio" href="#biblio-msvc">[MSVC]</a>, <a data-link-type="biblio" href="#biblio-gcc">[GCC]</a>, and <a data-link-type="biblio" href="#biblio-llvm">[LLVM]</a> support other representations. This means that the C++ that is taught
is effectively two’s complement, and the C++ that is written is two’s
complement. It is extremely unlikely that there exist any significant code base
developed for two’s complement machines that would actually work when run on a
non-two’s complement machine.</p>
   <p>The C++ that is spec’d, however, is not two’s complement. Signed integers
currently allow for trap representations, extra padding bits, integral negative
zero, and introduce undefined behavior and implementation-defined behavior for
the sake of this <em>extremely</em> abstract machine.</p>
   <p>Specifically, the current wording has the following effects:</p>
   <ul>
    <li data-md="">
     <p>Associativity and commutativity of integers is needlessly obtuse.</p>
    <li data-md="">
     <p>Naïve overflow checks, which are often security-critical, often get
eliminated by compilers. This leads to exploitable code when the intent was
clearly not to and the code, while naïve, was correctly performing security
checks for two’s complement integers. Correct overflow checks are difficult
to write and equally difficult to read, exponentially so in generic code.</p>
    <li data-md="">
     <p>Conversion between signed and unsigned are implementation-defined.</p>
    <li data-md="">
     <p>There is no portable way to generate an arithmetic right-shift, or to
sign-extend an integer, which every modern CPU supports.</p>
    <li data-md="">
     <p><code class="highlight"><span class="k">constexpr</span></code> is further restrained by this extraneous undefined behavior.</p>
    <li data-md="">
     <p>Atomic integral are already two’s complement and have no undefined results,
therefore even freestanding implementations already support two’s complement
in C++.</p>
   </ul>
   <p>Let’s stop pretending that the C++ abstract machine should represent integers as
signed magnitude or ones' complement. These theoretical implementations are a
different programming language, not our real-world C++. Users of C++ who require
signed magnitude or ones' complement integers would be better served by a
pure-library solution, and so would the rest of us.</p>
   <p>This proposal leaves C unchanged, it merely restricts further the subset of C
which applies to C++. The author will ensure that WG14 is made aware of this
paper’s outcome.</p>
   <p>A final argument to move to two’s complement is that few people spell "ones'
complement" correctly according to Knuth <a data-link-type="biblio" href="#biblio-taocp">[TAoCP]</a>. Reducing the nerd-snipe
potential inherent in C++ is a Good Thing™.</p>
   <blockquote>
    <p>Detail-oriented readers and copy editors should notice the position of the
  apostrophe in terms like “two’s complement” and “ones’ complement”: A two’s
  complement number is complemented with respect to a single power of 2, while a
  ones’ complement number is complemented with respect to a long sequence of
  1s. Indeed, there is also a “twos’ complement notation,” which has radix 3 and
  complementation with respect to (2 . . . 22)<sub>3</sub>.</p>
   </blockquote>
   <h2 class="heading settled" data-level="2" id="word"><span class="secno">2. </span><span class="content">Proposed Wording</span><a class="self-link" href="#word"></a></h2>
   <p>Modify Program execution [<strong>intro.execution</strong>] ❡8:</p>
   <blockquote>
    <p>[<em>Note:</em> Operators can be regrouped according to the usual mathematical
rules only where the operators really are associative or commutative.
For example, in the following fragment</p>
<pre class="highlight"><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">;</span>
<span class="cm">/* ... */</span>
<span class="n">a</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="mi">32760</span> <span class="o">+</span> <span class="n">b</span> <span class="o">+</span> <span class="mi">5</span><span class="p">;</span>
</pre>
    <p>the expression statement behaves exactly the same as</p>
<pre class="highlight"><span class="n">a</span> <span class="o">=</span> <span class="p">(</span><span class="p">(</span><span class="p">(</span><span class="n">a</span> <span class="o">+</span> <span class="mi">32760</span><span class="p">)</span> <span class="o">+</span> <span class="n">b</span><span class="p">)</span> <span class="o">+</span> <span class="mi">5</span><span class="p">)</span><span class="p">;</span>
</pre>
    <p>
     due to the associativity and precedence of these operators. Thus, the result of
the sum <code class="highlight"><span class="p">(</span><span class="n">a</span> <span class="o">+</span> <span class="mi">32760</span><span class="p">)</span></code> is next added to <code class="highlight"><span class="n">b</span></code>, and that result is then added to 5
which results in the value assigned to <code class="highlight"><span class="n">a</span></code>.
     <del> On a machine in which overflows
produce an exception and in which the range of values representable by an <code class="highlight"><span class="kt">int</span></code> is <code class="highlight"><span class="p">[</span><span class="o">-</span><span class="mi">32768</span><span class="p">,</span> <span class="o">+</span><span class="mi">32767</span><span class="p">]</span></code>, the implementation cannot rewrite this expression as</del>
    </p>
    <del>
<pre class="highlight">  <span class="n">a</span> <span class="o">=</span> <span class="p">(</span><span class="p">(</span><span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">)</span> <span class="o">+</span> <span class="mi">32765</span><span class="p">)</span><span class="p">;</span>
</pre>
    </del>
    <del>since if the values for <code class="highlight"><span class="n">a</span></code> and <code class="highlight"><span class="n">b</span></code> were, respectively, -32754 and -15, the sum <code class="highlight"><span class="n">a</span> <span class="o">+</span> <span class="n">b</span></code> would produce an exception while the original expression would not; nor
can the expression be rewritten either as</del>
    <del>
<pre class="highlight">  <span class="n">a</span> <span class="o">=</span> <span class="p">(</span><span class="p">(</span><span class="n">a</span> <span class="o">+</span> <span class="mi">32765</span><span class="p">)</span> <span class="o">+</span> <span class="n">b</span><span class="p">)</span><span class="p">;</span>
</pre>
    </del>
    <del>or</del>
    <del>
<pre class="highlight">  <span class="n">a</span> <span class="o">=</span> <span class="p">(</span><span class="n">a</span> <span class="o">+</span> <span class="p">(</span><span class="n">b</span> <span class="o">+</span> <span class="mi">32765</span><span class="p">)</span><span class="p">)</span><span class="p">;</span>
</pre>
    </del>
    <del>since the values for <code class="highlight"><span class="n">a</span></code> and <code class="highlight"><span class="n">b</span></code> might have been, respectively, 4 and -8 or -17
and 12. However on a machine in which overflows do not produce an exception and
in which the results of overflows are reversible, the above expression statement
can be rewritten by the implementation in any of the above ways because the same
result will occur.</del>
     —<em>end note</em>] 
   </blockquote>
   <p>Modify Fundamental types [<strong>basic.fundamental</strong>] ❡4 onwards:</p>
   <blockquote>
    <p>Unsigned integers shall obey the laws of arithmetic modulo 2<sup>n</sup> where <em>n</em> is the number of bits in the value representation of that particular size of
integer.</p>
    <blockquote>
     <p>This implies that unsigned arithmetic does not overflow because a result that
  cannot be represented by the resulting unsigned integer type is reduced modulo
  the number that is one greater than the largest value that can be represented
  by the resulting unsigned integer type.</p>
    </blockquote>
    <p>Type <code class="highlight"><span class="kt">wchar_t</span></code> is a distinct type whose values can represent distinct codes for
all members of the largest extended character set specified among the supported
locales. Type <code class="highlight"><span class="kt">wchar_t</span></code> shall have the same size, signedness, and alignment
requirements as one of the other integral types, called its <em>underlying type</em>.
Types <code class="highlight"><span class="kt">char16_t</span></code> and <code class="highlight"><span class="kt">char32_t</span></code> denote distinct types with the same size,
signedness, and alignment as <code class="highlight"><span class="kt">uint_least16_t</span></code> and <code class="highlight"><span class="kt">uint_least32_t</span></code>,
respectively, in <code class="highlight"><span class="o">&lt;</span><span class="n">cstdint</span><span class="o">></span></code>, called the underlying types.</p>
    <p>Values of type <code class="highlight"><span class="kt">bool</span></code> are either <code class="highlight">true</code> or <code class="highlight">false</code>. [<em>Note:</em> There are no <code class="highlight"><span class="kt">signed</span></code>, <code class="highlight"><span class="kt">unsigned</span></code>, <code class="highlight"><span class="kt">short</span></code>, or <code class="highlight"><span class="kt">long</span> <span class="kt">bool</span></code> types or values. —<em>end note</em>]
Values of type <code class="highlight"><span class="kt">bool</span></code> participate in integral promotions.</p>
    <p>
     Types <code class="highlight"><span class="kt">bool</span></code>, <code class="highlight"><span class="kt">char</span></code>, <code class="highlight"><span class="kt">char16_t</span></code>, <code class="highlight"><span class="kt">char32_t</span></code>, <code class="highlight"><span class="kt">wchar_t</span></code>, and the signed and
unsigned integer types are collectively called <em>integral</em> types. A synonym for
integral type is <em>integer type</em>. 
     <del>The representations of integral types
shall define values by use of a pure binary numeration system. [<em>Example:</em> This document permits two’s complement, ones' complement and signed magnitude
representations for integral types. —<em>end example</em>]</del>
    </p>
    <ins>Signed integer types shall be repesented as two’s complement. Overflow in
the positive direction shall wrap around from the maximum integer value for the
type back to the minimum, and overflow in the negative direction shall wrap
around from the minimum value for the type to the maximum.
[<em>Note:</em> Addition, subtraction, and multiplication on signed and unsigned
integral values with the same object representation produce a value with the
same object representation, whereas division and modulo do not.
—<em>end note</em>]</ins>
   </blockquote>
   <p>Modify Integral conversions [<strong>conv.integral</strong>] ❡1 onwards:</p>
   <blockquote>
    <p>A prvalue of an integer type can be converted to a prvalue of another integer
type. A prvalue of an unscoped enumeration type can be converted to a prvalue of
an integer type.</p>
    <p>
     If the destination type is unsigned, the resulting value is the least unsigned
integer congruent to the source integer (modulo 2<sup>n</sup> where <em>n</em> is the
number of bits used to represent the unsigned type). 
     <del>[<em>Note:</em> In a two’s
complement representation, t</del>
     <ins>T</ins>
     his conversion is conceptual and there is no change
in the bit pattern (if there is no truncation).
     <del> —<em>end note</em>]</del>
    </p>
    <p>
     If the destination type is signed, the value is unchanged if it can be
represented in the destination type; otherwise, 
     <del>the value is
implementation-defined.</del>
     <ins>the object representation remains the same if
the source and destination have the same size, or the least-significant source
bits are retained if the destination is smaller than the source.</ins>
    </p>
   </blockquote>
   <p>Modify Static cast [<strong>expr.static.cast</strong>] ❡1 onwards:</p>
   <blockquote>
    <p>
     A value of a scoped enumeration type can be explicitly converted to an integral
type. When that type is <em>cv</em> <code class="highlight"><span class="kt">bool</span></code>, the resulting value is <code class="highlight">false</code> if the
original value is zero and <code class="highlight">true</code> for all other values. For the remaining
integral types, the value is unchanged if the original value can be represented
by the specified type. Otherwise, the 
     <del>resulting value is
unspecified</del>
     <ins>the object representation remains the same if the source
and destination have the same size, or the least-significant source bits are
retained if the destination is smaller than the source</ins>
     . A value of a
scoped enumeration type can also be explicitly converted to a floating-point
type; the result is the same as that of converting from the original value to
the floating-point type.
    </p>
    <p>
     A value of integral or enumeration type can be explicitly converted to a
complete enumeration type.  If the enumeration type has a fixed underlying type,
the value is first converted to that type by integral conversion, if necessary,
and then to the enumeration type.  If the enumeration type does not have a fixed
underlying type, the value is unchanged if the original value is within the
range of the enumeration values, and otherwise, 
     <del>the behavior is
undefined</del>
     <ins>the object representation remains the same if the source and
destination have the same size, or the least-significant source bits are
retained if the destination is smaller than the source</ins>
     .  A value of
floating-point type can also be explicitly converted to an enumeration type.
The resulting value is the same as converting the original value to the
underlying type of the enumeration\iref{conv.fpint}, and subsequently to the
enumeration type.
    </p>
   </blockquote>
   <p>Modify Shift operators [<strong>expr.shift</strong>] ❡1 onwards:</p>
   <blockquote>
    <p>The operands shall be of integral or unscoped enumeration type and integral
promotions are performed. The type of the result is that of the promoted left
operand. The behavior is undefined if the right operand is negative, or greater
than or equal to the length in bits of the promoted left operand.</p>
    <p>
     The value of <code class="highlight"><span class="n">E1</span> <span class="o">&lt;</span><span class="o">&lt;</span> <span class="n">E2</span></code> is <code class="highlight"><span class="n">E1</span></code> left-shifted <code class="highlight"><span class="n">E2</span></code> bit positions; vacated bits
are zero-filled. 
     <del>If <code class="highlight"><span class="n">E1</span></code> has an unsigned type, t</del>
     <ins>T</ins>
     he value
of the result is E1×2<sup>E2</sup>, reduced modulo one more than the maximum
value representable in the result type.
     <del> Otherwise, if <code class="highlight"><span class="n">E1</span></code> has a signed
type and non-negative value, and E1×2<sup>E2</sup> is representable in the
corresponding unsigned type of the result type, then that value, converted to
the result type, is the resulting value; otherwise, the behavior is
undefined.</del>
    </p>
    <p>
     The value of <code class="highlight"><span class="n">E1</span> <span class="o">></span><span class="o">></span> <span class="n">E2</span></code> is <code class="highlight"><span class="n">E1</span></code> right-shifted <code class="highlight"><span class="n">E2</span></code> bit positions. If <code class="highlight"><span class="n">E1</span></code> has an
unsigned type or if <code class="highlight"><span class="n">E1</span></code> has a signed type and a non-negative value, the value
of the result is the integral part of the quotient of E1/2<sup>E2</sup>. If <code class="highlight"><span class="n">E1</span></code> has a signed type and a negative value, the resulting value 
     <del>is
implementation-defined.</del>
     <ins>the negative of the integral part of the
quotient of E1/2<sup>E2</sup>. [<em>Note</em>: This implies that right-shift on signed
integral types is an arithmetic right shift, and performs sign-extension.
—<em>end note</em>]</ins>
    </p>
   </blockquote>
   <p>Modify Constant expressions [<strong>expr.const</strong>] ❡2:</p>
   <blockquote>
    <p>An expression <code class="highlight"><span class="n">e</span></code> is a <em>core constant expression</em> unless the evaluation of <code class="highlight"><span class="n">e</span></code>,
following the rules of the abstract machine, would evaluate one of the following
expressions:</p>
    <p>[…]</p>
    <ul>
     <li data-md="">
      <p>
       an operation that would have undefined behavior as specified in Clause 4
through 19 of this document [<em>Note</em>: including, for example, 
       <del>signed
integer overflow, </del>
       certain pointer arithmetic, division
by zero, or certain shift operations —<em>end note</em>]
      </p>
    </ul>
   </blockquote>
   <p>Modify Enumeration declarations [<strong>dcl.enum</strong>] ❡8:</p>
   <blockquote>
    <p>
     For an enumeration whose underlying type is fixed, the values of the enumeration
are the values of the underlying type. Otherwise, for an enumeration where
e<sub>min</sub> is the smallest enumerator and e<sub>max</sub> is the largest,
the values of the enumeration are the values in the range b<sub>min</sub> to
b<sub>max</sub>, defined as follows: 
     <del>Let <em>K</em> be 1 for a two’s complement
representation and 0 for a ones' complement or sign-magnitude representation.</del>
      b<sub>max</sub> is the smallest value greater than or equal to
max(|e<sub>min</sub>| - 
     <del>K</del>
     <ins>1</ins>
     , |e<sub>max</sub>|) and equal to 2<sup>M</sup>-1,
where <em>M</em> is a non-negative integer. b<sub>min</sub> is zero if e<sub>min</sub> is non-negative and -(b<sub>max</sub>+
     <del>K</del>
     <ins>1</ins>
     ) otherwise. The size of the smallest
bit-field large enough to hold all the values of the enumeration type is
max(M,1) if b<sub>min</sub> is zero and M+1 otherwise. It is possible to define
an enumeration that has values not defined by any of its enumerators. If the <em>enumerator-list</em> is empty, the values of the enumeration are as if the
enumeration had a single enumerator with value 0.
    </p>
   </blockquote>
   <p>Modify <code class="highlight"><span class="n">numeric_limits</span></code> members [<strong>numeric.limits.members</strong>] ❡61 onwards:</p>
   <blockquote>
<pre class="highlight"><span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="n">is_modulo</span><span class="p">;</span></pre>
    <p><code class="highlight">true</code> if the type is modulo. A type is modulo if, for any operation involving <code class="highlight"><span class="o">+</span></code>, <code class="highlight"><span class="o">-</span></code>, or <code class="highlight"><span class="o">*</span></code> on values of that type whose result would fall outside the
range <code class="highlight"><span class="p">[</span><span class="n">min</span><span class="p">(</span><span class="p">)</span><span class="p">,</span> <span class="n">max</span><span class="p">(</span><span class="p">)</span><span class="p">]</span></code>, the value returned differs from the true value by
an integer multiple of <code class="highlight"><span class="n">max</span><span class="p">(</span><span class="p">)</span> <span class="o">-</span> <span class="n">min</span><span class="p">(</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span></code>.</p>
    <del>[<em>Example:</em><code class="highlight"><span class="n">is_modulo</span></code> is <code class="highlight">false</code> for signed integer types
unless an implementation, as an extension to this document,
defines signed integer overflow to wrap.  —<em>end example</em>]</del>
    <p>Meaningful for all specializations.</p>
   </blockquote>
   <p>Modify Class template <code class="highlight"><span class="n">ratio</span></code> [<strong>ratio.ratio</strong>] ❡1:</p>
   <blockquote>
    <p>
     If the template argument <code class="highlight"><span class="n">D</span></code> is zero or the absolute values of either of the
template arguments <code class="highlight"><span class="n">N</span></code> and <code class="highlight"><span class="n">D</span></code> is not representable by type <code class="highlight"><span class="kt">intmax_t</span></code>, the
program is ill-formed. [<em>Note:</em> These rules ensure that infinite ratios are
avoided and that for any negative input, there exists a representable value of
its absolute value which is positive. 
     <del>In a two’s complement representation, t</del>
     <ins>T</ins>
     his
excludes the most negative value. —<em>end note</em>]
    </p>
   </blockquote>
   <p>Remove Specializations for integers [<strong>atomics.types.int</strong>] ❡7:</p>
   <blockquote>
    <del><em>Remarks:</em> For signed integer types, arithmetic is defined to use two’s
complement representation. There are no undefined results.</del>
   </blockquote>
   <h2 class="heading settled" data-level="3" id="scope"><span class="secno">3. </span><span class="content">Out of Scope</span><a class="self-link" href="#scope"></a></h2>
   <p>This proposal focuses on the representation of signed integers, and on
tightening the specification when that representation is constrained to two’s
complement. It is out of scope for this proposal to deal with related issues
which have more to them than simply the representation of signed integers.</p>
   <p>A non-comprehensive list of items left purposefully out:</p>
   <ul>
    <li data-md="">
     <p>Left and right shift with a right-hand-side equal to or wider than the
bit-width of the left-hand-side.</p>
    <li data-md="">
     <p>Integral division or modulo by zero.</p>
    <li data-md="">
     <p>Integral division or modulo of the signed minimum integral value for a
particular integral type by minus one.</p>
    <li data-md="">
     <p>Overflow of pointer arithmetic.</p>
    <li data-md="">
     <p>Library solution for ones' complement integers.</p>
    <li data-md="">
     <p>Library solution for signed magnitude integers.</p>
    <li data-md="">
     <p>Library solution for two’s complement integers with trapping or undefined
overflow sepantics.</p>
    <li data-md="">
     <p>Language support for explicit signed overflow truncation such as Swift’s
(<code class="highlight"><span class="o">&amp;</span><span class="o">+</span></code>, <code class="highlight"><span class="o">&amp;</span><span class="o">-</span></code>, and <code class="highlight"><span class="o">&amp;</span><span class="o">*</span></code>), or complementary trapping overflow operators.</p>
    <li data-md="">
     <p>Library or language support for saturating arithmetic.</p>
    <li data-md="">
     <p>Mechanism to let the compiler assume that integers, signed or unsigned, do
not experience signed or unsigned wrapping for:</p>
     <ul>
      <li data-md="">
       <p>A specific integral variable.</p>
      <li data-md="">
       <p>All integral variables (à la <code class="highlight"><span class="o">-</span><span class="n">ftrapv</span></code>, <code class="highlight"><span class="o">-</span><span class="n">fno</span><span class="o">-</span><span class="n">wrapv</span></code>, and <code class="highlight"><span class="o">-</span><span class="n">fstrict</span><span class="o">-</span><span class="n">overflow</span></code>).</p>
      <li data-md="">
       <p>A specific loop’s induction variable.</p>
     </ul>
    <li data-md="">
     <p>Mechanism to have the compiler list places where it could benefit from
knowing that overflow cannot occur (à la <code class="highlight"><span class="o">-</span><span class="n">Wstrict</span><span class="o">-</span><span class="n">overflow</span></code>).</p>
    <li data-md="">
     <p>Endianness of integral storage (or endianness in general).</p>
    <li data-md="">
     <p>Bits per bytes, though we all know there are eight.</p>
   </ul>
   <p>These items could be tackled in separate proposals, unless the committee wants
them tackled here. This paper expresses no preference in whether they should be
addressed or how.</p>
   <h2 class="heading settled" data-level="4" id="c-sign"><span class="secno">4. </span><span class="content">C Signed Integer Wording</span><a class="self-link" href="#c-sign"></a></h2>
   <p>The following is the wording on integers from the C11 Standard.</p>
   <blockquote>
    <p>For unsigned integer types other than unsigned char, the bits of the object
  representation shall be divided into two groups: value bits and padding bits
  (there need not be any of the latter). If there are <em>N</em> value bits, each bit
  shall represent a different power of 2 between 1 and 2<sup>N−1</sup>, so that
  objects of that type shall be capable of representing values from 0 to
  2<sup>N</sup> − 1 using a pure binary representation; this shall be known as
  the value representation. The values of any padding bits are unspecified.</p>
    <p>For signed integer types, the bits of the object representation shall be
  divided into three groups: value bits, padding bits, and the sign bit. There
  need not be any padding bits; <code class="highlight"><span class="kt">signed</span> <span class="kt">char</span></code> shall not have any padding bits.
  There shall be exactly one sign bit. Each bit that is a value bit shall have
  the same value as the same bit in the object representation of the
  corresponding unsigned type (if there are <em>M</em> value bits in the signed type
  and <em>N</em> in the unsigned type, then M ≤ N). If the sign bit is zero, it shall
  not affect the resulting value. If the sign bit is one, the value shall be
  modified in one of the following ways:</p>
    <ul>
     <li data-md="">
      <p>the corresponding value with sign bit 0 is negated (<em>sign and magnitude</em>);</p>
     <li data-md="">
      <p>the sign bit has the value −(2<sup>M</sup>) (<em>two’s complement</em>);</p>
     <li data-md="">
      <p>the sign bit has the value −(2<sup>M</sup> − 1) (<em>ones’ complement</em>).</p>
    </ul>
    <p>Which of these applies is implementation-defined, as is whether the value with
  sign bit 1 and all value bits zero (for the first two), or with sign bit and
  all value bits 1 (for ones’ complement), is a trap representation or a normal
  value. In the case of sign and magnitude and ones’ complement, if this
  representation is a normal value it is called a <em>negative zero</em>.</p>
    <p>If the implementation supports negative zeros, they shall be generated only
  by:</p>
    <ul>
     <li data-md="">
      <p>the <code class="highlight"><span class="o">&amp;</span></code>, <code class="highlight"><span class="o">|</span></code>, <code class="highlight"><span class="o">^</span></code>, <code class="highlight"><span class="o">~</span></code>, <code class="highlight"><span class="o">&lt;</span><span class="o">&lt;</span></code>, and <code class="highlight"><span class="o">></span><span class="o">></span></code> operators with operands that produce such a value;</p>
     <li data-md="">
      <p>the <code class="highlight"><span class="o">+</span></code>, <code class="highlight"><span class="o">-</span></code>, <code class="highlight"><span class="o">*</span></code>, <code class="highlight"><span class="o">/</span></code>, and <code class="highlight"><span class="o">%</span></code> operators where one operand is a negative zero and the result is zero;</p>
     <li data-md="">
      <p>compound assignment operators based on the above cases.</p>
    </ul>
    <p>It is unspecified whether these cases actually generate a negative zero or a
  normal zero, and whether a negative zero becomes a normal zero when stored in
  an object.</p>
    <p>If the implementation does not support negative zeros, the behavior of the <code class="highlight"><span class="o">&amp;</span></code>, <code class="highlight"><span class="o">|</span></code>, <code class="highlight"><span class="o">^</span></code>, <code class="highlight"><span class="o">~</span></code>, <code class="highlight"><span class="o">&lt;</span><span class="o">&lt;</span></code>, and <code class="highlight"><span class="o">></span><span class="o">></span></code> operators with operands that would produce
  such a value is undefined.</p>
    <p>The values of any padding bits are unspecified. A valid (non-trap) object
  representation of a signed integer type where the sign bit is zero is a valid
  object representation of the corresponding unsigned type, and shall represent
  the same value. For any integer type, the object representation where all the
  bits are zero shall be a representation of the value zero in that type.</p>
    <p>The <em>precision</em> of an integer type is the number of bits it uses to represent
  values, excluding any sign and padding bits. The <em>width</em> of an integer type is
  the same but including any sign bit; thus for unsigned integer types the two
  values are the same, while for signed integer types the width is one greater
  than the precision.</p>
   </blockquote>
   <h2 class="heading settled" data-level="5" id="survey"><span class="secno">5. </span><span class="content">Survey of Signed Integer Representations</span><a class="self-link" href="#survey"></a></h2>
   <p>Here is a non-comprehensive history of signed integer representations:</p>
   <ul>
    <li data-md="">
     <p>Two’s complement</p>
     <ul>
      <li data-md="">
       <p>John von Neumann suggested use of two’s complement binary representation in his 1945 First Draft of a Report on the EDVAC proposal for an electronic stored-program digital computer.</p>
      <li data-md="">
       <p>The 1949 EDSAC, which was inspired by the First Draft, used two’s complement representation of binary numbers.</p>
      <li data-md="">
       <p>Early commercial two’s complement computers include the Digital Equipment Corporation PDP-5 and the 1963 PDP-6.</p>
      <li data-md="">
       <p>The System/360, introduced in 1964 by IBM, then the dominant player in the computer industry, made two’s complement the most widely used binary representation in the computer industry.</p>
      <li data-md="">
       <p>The first minicomputer, the PDP-8 introduced in 1965, uses two’s complement arithmetic as do the 1969 Data General Nova, the 1970 PDP-11.</p>
     </ul>
    <li data-md="">
     <p>Ones' complement</p>
     <ul>
      <li data-md="">
       <p>Many early computers, including the CDC 6600, the LINC, the PDP-1, and the UNIVAC 1107.</p>
      <li data-md="">
       <p>Successors of the CDC 6600 continued to use ones' complement until the late 1980s.</p>
      <li data-md="">
       <p>Descendants of the UNIVAC 1107, the UNIVAC 1100/2200 series, continue to do so, although ClearPath machines are a common platform that implement either the 1100/2200 architecture (the ClearPath IX series) or the Burroughs large systems architecture (the ClearPath NX series). Everything is common except the actual CPUs, which are implemented as ASICs. In addition to the IX (1100/2200) CPUs and the NX (Burroughs large systems) CPU, the architecture had Xeon (and briefly Itanium) CPUs. Unisys' goal was to provide an orderly transition for their 1100/2200 customers to a more modern architecture.</p>
     </ul>
    <li data-md="">
     <p>Signed magnitude</p>
     <ul>
      <li data-md="">
       <p>The IBM 700/7000 series scientific machines use sign/magnitude notation, except for the index registers which are two’s complement.</p>
     </ul>
   </ul>
   <p><a href="https://en.wikipedia.org/wiki/Two%27s_complement">Wikipedia</a> offers
more details and has comprehensive sources for the above.</p>
   <p>In short, the only machine the author could find using non-two’s complement are
made by Unisys. Nowadays they emulate their old architecture using x86 CPUs for
customers who have legacy applications which they’ve been unable to
migrate. These applications are unlikely to be well served by modern C++, signed
integers are the least of their problem. Post-modern C++ should focus on serving
its existing users well, and incoming users should be blissfully unaware of
integer esoterica.</p>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

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

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

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

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

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

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


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

    tocNav.appendChild(toggle);
  }

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

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

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

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-c11">[C11]
   <dd><a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf">Programming Languages — C</a>. URL: <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf">http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf</a>
   <dt id="biblio-gcc">[GCC]
   <dd><a href="https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html">GCC C Implementation-Defined Behavior: Integers</a>. URL: <a href="https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html">https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html</a>
   <dt id="biblio-llvm">[LLVM]
   <dd><a href="https://llvm.org/docs/LangRef.html">LLVM Language Reference Manual</a>. URL: <a href="https://llvm.org/docs/LangRef.html">https://llvm.org/docs/LangRef.html</a>
   <dt id="biblio-msvc">[MSVC]
   <dd><a href="https://docs.microsoft.com/en-us/cpp/c-language/integers">MSVC C Implementation-Defined Behavior: Integers</a>. URL: <a href="https://docs.microsoft.com/en-us/cpp/c-language/integers">https://docs.microsoft.com/en-us/cpp/c-language/integers</a>
   <dt id="biblio-taocp">[TAoCP]
   <dd>Donald Knuth. The Art of Computer Programming, Volume 2 (3rd Ed.): Seminumerical Algorithms. 
  </dl>