ID	Title
1	C library linkage editing oversight
2	Auto_ptr conversions effects incorrect
3	Atexit registration during atexit() call is not described
4	basic_string size_type and difference_type should be implementation defined
5	String::compare specification questionable
6	File position not an offset unimplementable
7	String clause minor problems
8	Locale::global lacks guarantee
9	Operator new(0) calls should not yield the same pointer
10	Codecvt<>::do unclear
11	Bitset minor problems
12	Way objects hold allocators unclear
13	Eos refuses to die
14	Locale::combine should be const
15	Locale::name requirement inconsistent
16	Bad ctype_byname<char> decl
17	Bad bool parsing
18	Get(...bool&) omitted
19	"Noconv" definition too vague
20	Thousands_sep returns wrong type
21	Codecvt_byname<> instantiations
22	Member open vs. flags
23	Num_get overflow result
24	"do_convert" doesn't exist
25	String operator<< uses width() value wrong
26	Bad sentry example
27	String::erase(range) yields wrong iterator
28	Ctype<char>is ambiguous
29	Ios_base::init doesn't exist
30	Wrong header for LC_*
31	Immutable locale values
32	Pbackfail description inconsistent
33	Codecvt<> mentions from_type
34	True/falsename() not in ctype<>
35	No manipulator unitbuf in synopsis
36	Iword & pword storage lifetime omitted
37	Leftover "global" reference
38	Facet definition incomplete
39	istreambuf_iterator<>::operator++(int) definition garbled
40	Meaningless normative paragraph in examples
41	Ios_base needs clear(), exceptions()
42	String ctors specify wrong default allocator
43	Locale table correction
44	Iostreams use operator== on int_type values
45	Stringstreams read/write pointers initial position unclear
46	Minor Annex D errors
47	Imbue() and getloc() Returns clauses swapped
48	Use of non-existent exception constructor
49	Underspecification of ios_base::sync_with_stdio
50	Copy constructor and assignment operator of ios_base
51	Requirement to not invalidate iterators missing
52	Small I/O problems
53	Basic_ios destructor unspecified
54	Basic_streambuf's destructor
55	Invalid stream position is undefined
56	Showmanyc's return type
57	Mistake in char_traits
58	Extracting a char from a wide-oriented stream
59	Ambiguity in specification of gbump
60	What is a formatted input function?
61	Ambiguity in iostreams exception policy
62	Sync's return value
63	Exception-handling policy for unformatted output
64	Exception handling in basic_istream::operator>>(basic_streambuf*)
65	Underspecification of strstreambuf::seekoff
66	Strstreambuf::setbuf
67	Setw useless for strings
68	Extractors for char* should store null at end
69	Must elements of a vector be contiguous?
70	Uncaught_exception() missing throw() specification
71	Do_get_monthname synopsis missing argument
72	Do_convert phantom member function
73	is_open should be const
74	Garbled text for codecvt::do_max_length
75	Contradiction in codecvt::length's argument types
76	Can a codecvt facet always convert one internal character at a time?
77	Valarray operator[] const returning value
78	Typo: event_call_back
79	Inconsistent declaration of polar()
80	Global Operators of complex declared twice
81	Wrong declaration of slice operations
82	Missing constant for set elements
83	String::npos vs. string::max_size()
84	Ambiguity with string::insert()
85	String char types
86	String constructors don't describe exceptions
87	Error in description of string::compare()
88	Inconsistency between string::insert() and string::append()
89	Missing throw specification for string::insert() and string::replace()
90	Incorrect description of operator >> for strings
91	Description of operator>> and getline() for string<> might cause endless loop
92	Incomplete Algorithm Requirements
93	Incomplete Valarray Subset Definitions
94	May library implementors add template parameters to Standard Library classes?
95	Members added by the implementation
96	Vector<bool> is not a container
97	Insert inconsistent definition
98	Input iterator requirements are badly written
99	Reverse_iterator comparisons completely wrong
100	Insert iterators/ostream_iterators overconstrained
101	No way to free storage for vector and deque
102	Bug in insert range in associative containers
103	set::iterator is required to be modifiable, but this allows modification of keys
104	Description of basic_string::operator[] is unclear
105	fstream ctors argument types desired
106	Numeric library private members are implementation defined
107	Valarray constructor is strange
108	Lifetime of exception::what() return unspecified
109	Missing binders for non-const sequence elements
110	istreambuf_iterator::equal not const
111	istreambuf_iterator::equal overspecified, inefficient
112	Minor typo in ostreambuf_iterator constructor
113	Missing/extra iostream sync semantics
114	Placement forms example in error twice
115	Typo in strstream constructors
116	bitset cannot be constructed with a const char*
117	basic_ostream uses nonexistent num_put member functions
118	basic_istream uses nonexistent num_get member functions
119	Should virtual functions be allowed to strengthen the exception specification?
120	Can an implementor add specializations?
121	Detailed definition for ctype<wchar_t> specialization
122	streambuf/wstreambuf description should not say they are specializations
123	Should valarray helper arrays fill functions be const?
124	ctype_byname<charT>::do_scan_is & do_scan_not return type should be const charT*
125	valarray<T>::operator!() return type is inconsistent
126	typos in Effects clause of ctype::do_narrow()
127	auto_ptr<> conversion issues
128	Need open_mode() function for file stream, string streams, file buffers, and string  buffers
129	Need error indication from seekp() and seekg()
130	Return type of container::erase(iterator) differs for associative containers
131	list::splice throws nothing
132	list::resize description uses random access iterators
133	map missing get_allocator()
134	vector constructors over specified
135	basic_iostream doubly initialized
136	seekp, seekg setting wrong streams?
137	Do use_facet and has_facet look in the global locale?
138	Class ctype_byname<char> redundant and misleading
139	Optional sequence operation table description unclear
140	map<Key, T>::value_type does not satisfy the assignable requirement
141	basic_string::find_last_of, find_last_not_of say pos instead of xpos
142	lexicographical_compare complexity wrong
143	C .h header wording unclear
144	Deque constructor complexity wrong
145	adjustfield lacks default value
146	complex<T> Inserter and Extractor need sentries
147	Library Intro refers to global functions that aren't global
148	Functions in the example facet BoolNames should be const
149	Insert should return iterator to first element inserted
150	Find_first_of says integer instead of iterator
151	Can't currently clear() empty container
152	Typo in scan_is() semantics
153	Typo in narrow() semantics
154	Missing double specifier for do_get()
155	Typo in naming the class defining the class Init
156	Typo in imbue() description
157	Meaningless error handling for pword() and iword()
158	Underspecified semantics for setbuf()
159	Strange use of underflow()
160	Typo: Use of non-existing function exception()
161	Typo: istream_iterator vs. istreambuf_iterator
162	Really "formatted input functions"?
163	Return of gcount() after a call to gcount
164	do_put() has apparently unused fill argument
165	xsputn(), pubsync() never called by basic_ostream members?
166	Really "formatted output functions"?
167	Improper use of traits_type::length()
168	Typo: formatted vs. unformatted
169	Bad efficiency of overflow() mandated
170	Inconsistent definition of traits_type
171	Strange seekpos() semantics due to joint position
172	Inconsistent types for basic_istream::ignore()
173	Inconsistent types for basic_filebuf::setbuf()
174	Typo: OFF_T vs. POS_T
175	Ambiguity for basic_streambuf::pubseekpos() and a few other functions.
176	exceptions() in ios_base...?
177	Complex operators cannot be explicitly instantiated
178	Should clog and cerr initially be tied to cout?
179	Comparison of const_iterators to iterators doesn't work
180	Container member iterator arguments constness has unintended consequences
181	make_pair() unintended behavior
182	Ambiguous references to size_t
183	I/O stream manipulators don't work for wide character streams
184	numeric_limits<bool> wording problems
185	Questionable use of term "inline"
186	bitset::set() second parameter should be bool
187	iter_swap underspecified
188	valarray helpers missing augmented assignment operators
189	setprecision() not specified correctly
190	min() and max() functions should be std::binary_functions
191	Unclear complexity for algorithms such as binary search
192	a.insert(p,t) is inefficient and overconstrained
193	Heap operations description incorrect
194	rdbuf() functions poorly specified
195	Should basic_istream::sentry's constructor ever set eofbit?
196	Placement new example has alignment problems
197	max_size() underspecified
198	Validity of pointers and references unspecified after iterator destruction
199	What does allocate(0) return?
200	Forward iterator requirements don't allow constant iterators
201	Numeric limits terminology wrong
202	unique() effects unclear when predicate not an equivalence relation
203	basic_istream::sentry::sentry() is uninstantiable with ctype<user-defined type>
204	distance(first, last) when "last" is before "first"
205	numeric_limits unclear on how to determine floating point types
206	operator new(size_t, nothrow) may become unlinked to ordinary operator new if ordinary version replaced
207	ctype<char> members return clause incomplete
208	Unnecessary restriction on past-the-end iterators
209	basic_string declarations inconsistent
210	distance first and last confused
211	operator>>(istream&, string&) doesn't set failbit
212	Empty range behavior unclear for several algorithms
213	Math function overloads ambiguous
214	set::find() missing const overload
215	Can a map's key_type be const?
216	setbase manipulator description flawed
217	Facets example (Classifying Japanese characters) contains errors
218	Algorithms do not use binary predicate objects for default comparisons
219	find algorithm missing version that takes a binary predicate argument
220	~ios_base() usage valid?
221	num_get<>::do_get stage 2 processing broken
222	Are throw clauses necessary if a throw is already implied by the effects clause?
223	reverse algorithm should use iter_swap rather than swap
224	clear() complexity for associative containers refers to undefined N
225	std:: algorithms use of other unqualified algorithms
226	User supplied specializations or overloads of namespace std function templates
227	std::swap() should require CopyConstructible or DefaultConstructible arguments
228	Incorrect specification of "..._byname" facets
229	Unqualified references of other library entities
230	Assignable specified without also specifying CopyConstructible
231	Precision in iostream?
232	"depends" poorly defined in 17.4.3.1
233	Insertion hints in associative containers
234	Typos in allocator definition
235	No specification of default ctor for reverse_iterator
236	ctype<char>::is() member modifies facet
237	Undefined expression in complexity specification
238	Contradictory results of stringbuf initialization.
239	Complexity of unique() and/or unique_copy incorrect
240	Complexity of adjacent_find() is meaningless
241	Does unique_copy() require CopyConstructible and Assignable?
242	Side effects of function objects
243	get and getline when sentry reports failure
244	Must find's third argument be CopyConstructible?
245	Which operations on istream_iterator trigger input operations?
246	a.insert(p,t) is incorrectly specified
247	vector, deque::insert complexity
248	time_get fails to set eofbit
249	Return Type of auto_ptr::operator=
250	splicing invalidates iterators
251	basic_stringbuf missing allocator_type
252	missing casts/C-style casts used in iostreams
253	valarray helper functions are almost entirely useless
254	Exception types in clause 19 are constructed from std::string
255	Why do basic_streambuf<>::pbump() and gbump() take an int?
256	typo in 27.4.4.2, p17: copy_event does not exist
257	STL functional object and iterator inheritance.
258	Missing allocator requirement
259	basic_string::operator[] and const correctness
260	Inconsistent return type of istream_iterator::operator++(int)
261	Missing description of istream_iterator::operator!=
262	Bitmask operator ~ specified incorrectly
263	Severe restriction on basic_string reference counting
264	Associative container insert(i, j) complexity requirements are not feasible.
265	std::pair::pair() effects overly restrictive
266	bad_exception::~bad_exception() missing Effects clause
267	interaction of strstreambuf::overflow() and seekoff()
268	Typo in locale synopsis
269	cstdarg and unnamed parameters
270	Binary search requirements overly strict
271	basic_iostream missing typedefs
272	Missing parentheses around subexpression
273	Missing ios_base qualification on members of a dependent class
274	a missing/impossible allocator requirement
275	Wrong type in num_get::get() overloads
276	Assignable requirement for container value type overly strict
277	Normative encouragement in allocator requirements unclear
278	What does iterator validity mean?
279	const and non-const iterators should have equivalent typedefs
280	Comparison of reverse_iterator to const reverse_iterator
281	std::min() and max() requirements overly restrictive
282	What types does numpunct grouping refer to?
283	std::replace() requirement incorrect/insufficient
284	unportable example in 20.3.7, p6
285	minor editorial errors in fstream ctors
286	<cstdlib> requirements missing size_t typedef
287	conflicting ios_base fmtflags
288	<cerrno> requirements missing macro EILSEQ
289	<cmath> requirements missing C float and long double versions
290	Requirements to for_each and its function object
291	Underspecification of set algorithms
292	effects of a.copyfmt (a)
293	Order of execution in transform algorithm
294	User defined macros and standard headers
295	Is abs defined in <cmath>?
296	Missing descriptions and requirements of pair operators
297	const_mem_fun_t<>::argument_type should be const T*
298	::operator delete[] requirement incorrect/insufficient
299	Incorrect return types for iterator dereference
300	list::merge() specification incomplete
301	basic_string template ctor effects clause omits allocator argument
302	Need error indication from codecvt<>::do_length
303	Bitset input operator underspecified
304	Must *a return an lvalue when a is an input iterator?
305	Default behavior of codecvt<wchar_t, char, mbstate_t>::length()
306	offsetof macro and non-POD types
307	Lack of reference typedefs in container adaptors
308	Table 82 mentions unrelated headers
309	Does sentry catch exceptions?
310	Is errno a macro?
311	Incorrect wording in basic_ostream class synopsis
312	Table 27 is missing headers
313	set_terminate and set_unexpected question
314	Is the stack unwound when terminate() is called?
315	Bad "range" in list::unique complexity
316	Vague text in Table 69
317	Instantiation vs. specialization of facets
318	Misleading comment in definition of numpunct_byname
319	Storage allocation wording confuses "Required behavior", "Requires"
320	list::assign overspecified
321	Typo in num_get
322	iterator and const_iterator should have the same value type
323	abs() overloads in different headers
324	Do output iterators have value types?
325	Misleading text in moneypunct<>::do_grouping
326	Missing typedef in moneypunct_byname
327	Typo in time_get facet in table 52
328	Bad sprintf format modifier in money_put<>::do_put()
329	vector capacity, reserve and reallocation
330	Misleading "exposition only" value in class locale definition
331	bad declaration of destructor for ios_base::failure
332	Consider adding increment and decrement operators to std::fpos< T >
333	does endl imply synchronization with the device?
334	map::operator[] specification forces inefficient implementation
335	minor issue with char_traits, table 37
336	Clause 17 lack of references to deprecated headers
337	replace_copy_if's template parameter should be InputIterator
338	is whitespace allowed between `-' and a digit?
339	definition of bitmask type restricted to clause 27
340	interpretation of has_facet<Facet>(loc)
341	Vector reallocation and swap
342	seek and eofbit
343	Unspecified library header dependencies
344	grouping + showbase
345	type tm in <cwchar>
346	Some iterator member functions should be const
347	locale::category and bitmask requirements
348	Minor issue with std::pair operator<
349	Minor typographical error in ostream_iterator
350	allocator<>::address
351	unary_negate and binary_negate: struct or class?
352	missing fpos requirements
353	std::pair missing template assignment
354	Associative container lower/upper bound requirements
355	Operational semantics for a.back()
356	Meaning of ctype_base::mask enumerators
357	<cmath> float functions cannot return HUGE_VAL
358	interpreting thousands_sep after a decimal_point
359	num_put<>::do_put (..., bool) undocumented
360	locale mandates inefficient implementation
361	num_get<>::do_get (..., void*&) checks grouping
362	bind1st/bind2nd type safety
363	Missing exception specification in 27.4.2.1.1
364	Inconsistent wording in 27.5.2.4.2
365	Lack of const-qualification in clause 27
366	Excessive const-qualification
367	remove_copy/remove_copy_if and Input Iterators
368	basic_string::replace has two "Throws" paragraphs
369	io stream objects and static ctors
370	Minor error in basic_istream::get
371	Stability of multiset and multimap member functions
372	Inconsistent description of stdlib exceptions
373	Are basic_istream and basic_ostream to use (exceptions()&badbit) != 0 ?
374	moneypunct::frac_digits returns int not unsigned
375	basic_ios should be ios_base in 27.7.1.3
376	basic_streambuf semantics
377	basic_string::insert and length_error
378	locale immutability and locale::operator=()
379	nonsensical ctype::do_widen() requirement
380	typos in codecvt tables 53 and 54
381	detection of invalid mbstate_t in codecvt
382	codecvt do_in/out result
383	Bidirectional iterator assertion typo
384	equal_range has unimplementable runtime complexity
385	Does call by value imply the CopyConstructible requirement?
386	Reverse iterator's operator[] has impossible return type
387	std::complex over-encapsulated
388	Use of complex as a key in associative containers
389	Const overload of valarray::operator[] returns by value
390	CopyConstructible requirements too strict
391	non-member functions specified as const
392	'equivalence' for input iterators
393	do_in/do_out operation on state unclear
394	behavior of formatted output on failure
395	inconsistencies in the definitions of rand() and random_shuffle()
396	what are characters zero and one
397	ostream::sentry dtor throws exceptions
398	effects of end-of-file on unformatted input functions
399	volations of unformatted input function requirements
400	redundant type cast in lib.allocator.members
401	incorrect type casts in table 32 in lib.allocator.requirements
402	wrong new expression in [some_]allocator::construct
403	basic_string::swap should not throw exceptions
404	May a replacement allocation function be declared inline?
405	qsort and POD
406	vector::insert(s) exception safety
407	Can singular iterators be destroyed?
408	Is vector<reverse_iterator<char*> > forbidden?
409	Closing an fstream should clear error state
410	Missing semantics for stack and queue comparison operators
411	Wrong names of set member functions
412	Typo in 27.4.4.3
413	Proposed resolution to LDR#64 still wrong
414	Which iterators are invalidated by v.erase()?
415	behavior of std::ws
416	definitions of XXX_MIN and XXX_MAX macros in climits
417	what does ctype::do_widen() return on failure
418	exceptions thrown during iostream cleanup
419	istream extractors not setting failbit if eofbit is already set
420	is std::FILE a complete type?
421	is basic_streambuf copy-constructible?
422	explicit specializations of member functions of class templates
423	Effects of negative streamsize in iostreams
424	normative notes
425	return value of std::get_temporary_buffer
426	search_n(), fill_n(), and generate_n() with negative n
427	Stage 2 and rationale of DR 221
428	string::erase(iterator) validity
429	typo in basic_ios::clear(iostate)
430	valarray subset operations
431	Swapping containers with unequal allocators
432	stringbuf::overflow() makes only one write position available
433	Contradiction in specification of unexpected()
434	bitset::to_string() hard to use
435	bug in DR 25
436	are cv-qualified facet types valid facets?
437	Formatted output of function pointers is confusing
438	Ambiguity in the "do the right thing" clause
439	Should facets be copyable?
440	Should std::complex use unqualified transcendentals?
441	Is fpos::state const?
442	sentry::operator bool() inconsistent signature
443	filebuf::close() inconsistent use of EOF
444	Bad use of casts in fstream
445	iterator_traits::reference unspecified for some iterator categories
446	Iterator equality between different containers
447	Wrong template argument for time facets
448	Random Access Iterators over abstract classes
449	Library Issue 306 Goes Too Far
450	set::find is inconsistent with associative container requirements
451	Associative erase should return an iterator
452	locale::combine should be permitted to generate a named locale
453	basic_stringbuf::seekoff need not always fail for an empty stream
454	basic_filebuf::open should accept wchar_t names
455	cerr::tie() and wcerr::tie() are overspecified
456	Traditional C header files are overspecified
457	bitset constructor: incorrect number of initialized bits
458	24.1.5 contains unintended limitation for operator-
459	Requirement for widening in stage 2 is overspecification
460	Default modes missing from basic_fstream member specifications
461	time_get hard or impossible to implement
462	Destroying objects with static storage duration
463	auto_ptr usability issues
464	Suggestion for new member functions in standard containers
465	Contents of <ciso646>
466	basic_string ctor should prevent null pointer error
467	char_traits::lt(), compare(), and memcmp()
468	unexpected consequences of ios_base::operator void*()
469	vector<bool> ill-formed relational operators
470	accessing containers from their elements' special functions
471	result of what() implementation-defined
472	Missing "Returns" clause in std::equal_range
473	underspecified ctype calls
474	confusing Footnote 297
475	May the function object passed to for_each modify the elements of the iterated sequence?
476	Forward Iterator implied mutability
477	Operator-> for const forward iterators
478	Should forward iterator requirements table have a line for r->m?
479	Container requirements and placement new
480	unary_function and binary_function should have protected nonvirtual destructors
481	unique's effects on the range [result, last)
482	Swapping pairs
483	Heterogeneous equality and EqualityComparable
484	Convertible to T
485	output iterator insufficiently constrained
486	min/max CopyConstructible requirement is too strict
487	Allocator::construct is too limiting
488	rotate throws away useful information
489	std::remove / std::remove_if wrongly specified
490	std::unique wrongly specified
491	std::list<>::unique incorrectly specified
492	Invalid iterator arithmetic expressions
493	Undefined Expression in Input Iterator Note Title
494	Wrong runtime complexity for associative container's insert and delete
495	Clause 22 template parameter requirements
496	Illegal use of "T" in vector<bool>
497	meaning of numeric_limits::traps for floating point types
498	Requirements for partition() and stable_partition() too strong
499	Std. doesn't seem to require stable_sort() to be stable!
500	do_length cannot be implemented correctly
501	Proposal: strengthen guarantees of lib.comparisons
502	Proposition: Clarification of the interaction between a facet and an iterator
503	more on locales
504	Integer types in pseudo-random number engine requirements
505	Result_type in random distribution requirements
506	Requirements of Distribution parameter for variate_generator
507	Missing requirement for variate_generator::operator()
508	Bad parameters for ranlux64_base_01
509	Uniform_int template parameters
510	Input_type for bernoulli_distribution
511	Input_type for binomial_distribution
512	Seeding subtract_with_carry_01 from a single unsigned long
513	Size of state for subtract_with_carry_01
514	Size of state for subtract_with_carry
515	Random number engine traits
516	Seeding subtract_with_carry_01 using a generator
517	Should include name in external representation
518	Are insert and erase stable for unordered_multiset and unordered_multimap?
519	Data() undocumented
520	Result_of and pointers to data members
521	Garbled requirements for argument_type in reference_wrapper
522	Tuple doesn't define swap
523	regex case-insensitive character ranges are unimplementable as specified
524	regex named character classes and case-insensitivity don't mix
525	type traits definitions not clear
526	Is it undefined if a function in the standard changes in parameters?
527	tr1::bind has lost its Throws clause
528	const_iterator iterator issue when they are the same type
529	The standard encourages redundant and confusing preconditions
530	Must elements of a string be contiguous?
531	array forms of unformatted input functions
532	Tuple comparison
533	typo in 2.2.3.10/1
534	Missing basic_string members
535	std::string::swap specification poorly worded
536	Container iterator constructor and explicit convertibility
537	Typos in the signatures in 27.6.1.3/42-43 and 27.6.2.4
538	241 again: Does unique_copy() require CopyConstructible and Assignable?
539	partial_sum and adjacent_difference should mention requirements
540	shared_ptr<void>::operator*()
541	shared_ptr template assignment and void
542	shared_ptr observers
543	valarray slice default constructor
544	minor NULL problems in C.2
545	When is a deleter deleted?
546	[tr1] _Longlong and _ULonglong are integer types
547	division should be floating-point, not integer
548	May random_device block?
549	Undefined variable in binomial_distribution
550	What should the return type of pow(float,int) be?
551	<ccomplex>
552	random_shuffle and its generator
553	very minor editorial change intptr_t / uintptr_t
554	Problem with lwg DR 184 numeric_limits<bool>
555	[tr1] 8.21/1: typo
556	Is Compare a BinaryPredicate?
557	TR1: div(_Longlong, _Longlong) vs div(intmax_t, intmax_t)
558	lib.input.iterators Defect
559	numeric_limits<const T>
560	User-defined allocators without default constructor
561	inserter overly generic
562	stringbuf ctor inefficient
563	stringbuf seeking from end
564	stringbuf seekpos underspecified
565	xsputn inefficient
566	array forms of unformatted input function undefined for zero-element arrays
567	streambuf inserter and extractor should be unformatted
568	[tr1] log2 overloads missing
569	Postcondition for basic_ios::clear(iostate) incorrectly stated
570	Request adding additional explicit specializations of char_traits
571	Update C90 references to C99?
572	Oops, we gave 507 WP status
573	C++0x file positioning should handle modern file sizes
574	DR 369 Contradicts Text
575	the specification of ~shared_ptr is MT-unfriendly, makes implementation assumptions
576	find_first_of is overconstrained
577	upper_bound(first, last, ...) cannot return last
578	purpose of hint to allocator::allocate()
579	erase(iterator) for unordered containers should not return an iterator
580	unused allocator members
581	flush() not unformatted function
582	specialized algorithms and volatile storage
583	div() for unsigned integral types
584	missing int pow(int,int) functionality
585	facet error reporting
586	string inserter not a formatted function
587	iststream ctor missing description
588	requirements on zero sized tr1::arrays and other details
589	Requirements on iterators of member template functions of containers
590	Type traits implementation latitude should be removed for C++0x
591	Misleading "built-in
592	Incorrect treatment of rdbuf()->close() return type
593	__STDC_CONSTANT_MACROS
594	Disadvantages of defining Swappable in terms of CopyConstructible and Assignable
595	TR1/C++0x: fabs(complex<T>) redundant / wrongly specified
596	27.8.1.3 Table 112 omits "a+" and "a+b" modes
597	[dec.tr] The notion of 'promotion' cannot be emulated by user-defined types.
598	[dec.tr] Conversion to integral should truncate, not round.
599	[dec.tr] Say "octets" instead of "bytes."
600	[dec.tr] Wrong parameters for wcstod* functions
601	[dec.tr] numeric_limits typos
602	[dec.tr] "generic floating type" not defined.
603	[dec.tr] Trivially simplifying decimal classes.
604	[dec.tr] Storing a reference to a facet unsafe.
605	[dec.tr] <decfloat.h> doesn't live here anymore.
606	[dec.tr] allow narrowing conversions
607	Concern about short seed vectors
608	Unclear seed_seq construction details
609	missing static const
610	Suggested non-normative note for C++0x
611	Standard library templates and incomplete types
612	numeric_limits::is_modulo insufficiently defined
613	max_digits10 missing from numeric_limits
614	std::string allocator requirements still inconsistent
615	Inconsistencies in Section 21.4
616	missing 'typename' in ctype_byname
617	std::array is a sequence that doesn't satisfy the sequence requirements?
618	valarray::cshift() effects on empty array
619	Longjmp wording problem
620	valid uses of empty valarrays
621	non-const copy assignment operators of helper arrays
622	behavior of filebuf dtor and close on error
623	pubimbue forbidden to call imbue
624	valarray assignment and arrays of unequal length
625	Mixed up Effects and Returns clauses
626	new Remark clauses not documented
627	Low memory and exceptions
628	Inconsistent definition of basic_regex constructor
629	complex<T> insertion and locale dependence
630	arrays of valarray
631	conflicting requirements for BinaryPredicate
632	Time complexity of size() for std::set
633	Return clause mentions undefined "type()"
634	allocator.address() doesn't work for types overloading operator&
635	domain of allocator::address
636	26.5.2.3 valarray::operator[]
637	§[c.math]/10 inconsistent return values
638	deque end invalidation during erase
639	Still problems with exceptions during streambuf IO
640	27.6.2.5.2 does not handle (unsigned) long long
641	Editorial fix for 27.6.4 (N2134)
642	Invalidated fstream footnotes in N2134
643	Impossible "as if" clauses
644	Possible typos in 'function' description
645	Missing members in match_results
646	const incorrect match_result members
647	Inconsistent regex_search params
648	regex_iterator c'tor needs clarification/editorial fix
649	Several typos in regex_token_iterator constructors
650	regex_token_iterator and const correctness
651	Missing preconditions for regex_token_iterator c'tors
652	regex_iterator and const correctness
653	Library reserved names
654	Missing IO roundtrip for random number engines
655	Signature of generate_canonical not useful
656	Typo in subtract_with_carry_engine declaration
657	unclear requirement about header inclusion
658	Two unspecified function comparators in [function.objects]
659	istreambuf_iterator should have an operator->()
660	Missing Bitwise Operations
661	New 27.6.1.2.2 changes make special extractions useless
662	Inconsistent handling of incorrectly-placed thousands separators
663	Complexity Requirements
664	do_unshift for codecvt<char, char, mbstate_t>
665	do_unshift return value
666	moneypunct::do_curr_symbol()
667	money_get's widened minus sign
668	money_get's empty minus sign
669	Equivalent postive and negative signs in money_get
670	money_base::pattern and space
671	precision of hexfloat
672	Swappable requirements need updating
673	unique_ptr update
674	shared_ptr interface changes for consistency with N1856
675	Move assignment of containers
676	Moving the unordered containers
677	Weaknesses in seed_seq::randomize [rand.util.seedseq]
678	Changes for [rand.req.eng]
679	resize parameter by value
680	move_iterator operator-> return
681	Operator functions impossible to compare are defined in [re.submatch.op]
682	basic_regex ctor takes InputIterator or ForwardIterator?
683	regex_token_iterator summary error
684	Unclear which members of match_results should be used in comparison
685	reverse_iterator/move_iterator difference has invalid signatures
686	unique_ptr and shared_ptr fail to specify non-convertibility to int for unspecified-bool-type
687	shared_ptr conversion constructor not constrained
688	reference_wrapper, cref unsafe, allow binding to rvalues
689	reference_wrapper constructor overly constrained
690	abs(long long) should return long long
691	const_local_iterator cbegin, cend missing from TR1
692	get_money and put_money should be formatted I/O functions
693	std::bitset::all() missing
694	std::bitset and long long
695	ctype<char>::classic_table() not accessible
696	istream::operator>>(int&) broken
697	New <system_error> header leads to name clashes
698	system_error needs const char* constructors
699	N2111 changes min/max
700	N1856 defines struct identity
701	[tr1] assoc laguerre poly's
702	[tr1] Restriction in associated Legendre functions
703	map::at() need a complexity specification
704	MoveAssignable requirement for container value type overly strict
705	type-trait decay incompletely specified
706	make_pair() should behave as make_tuple() wrt. reference_wrapper()
707	null pointer constant for exception_ptr
708	Locales need to be per thread and updated for POSIX changes
709	char_traits::not_eof has wrong signature
710	Missing postconditions
711	Contradiction in empty shared_ptr
712	seed_seq::size no longer useful
713	sort() complexity is too lax
714	search_n complexity is too lax
715	minmax_element complexity is too lax
716	Production in [re.grammar] not actually modified
717	Incomplete valarray::operator[] specification in [valarray.access]
718	basic_string is not a sequence
719	std::is_literal type traits should be provided
720	Omissions in constexpr usages
721	wstring_convert inconsistensies
722	Missing [c.math] functions nanf and nanl
723	basic_regex should be moveable
724	DefaultConstructible is not defined
725	Optional sequence container requirements column label
726	Missing regex_replace() overloads
727	regex_replace() doesn't accept basic_strings with custom traits and allocators
728	Problem in [rand.eng.mers]/6
729	Problem in [rand.req.eng]/3
730	Comment on [rand.req.adapt]/3 e)
731	proposal for a customizable seed_seq
732	Defect in [rand.dist.samp.genpdf]
733	Comment on [rand.req.dist]/9
734	Unnecessary restriction in [rand.dist.norm.chisq]
735	Unfortunate naming
736	Comment on [rand.dist.samp.discrete]
737	Comment on [rand.dist.samp.pconst]
738	Editorial issue in [rand.adapt.disc]/3
739	Defect in [rand.util.canonical]/3
740	Please remove *_ptr<T[N]>
741	Const-incorrect get_deleter function for shared_ptr
742	Enabling swap for proxy iterators
743	rvalue swap for shared_ptr
744	What is the lifetime of an exception pointed to by an exception_ptr?
745	copy_exception API slices.
746	current_exception may fail with bad_alloc
747	We have 3 separate type traits to identify classes supporting no-throw operations
748	The is_abstract type trait is defined by reference to 10.4.
749	Currently has_nothrow_copy_constructor<T>::value is true if T has 'a' nothrow copy constructor.
750	The current definition for is_convertible requires that the type be implicitly convertible, so explicit constructors are ignored.
751	change pass-by-reference members of vector<bool> to pass-by-value?
752	Allocator complexity requirement
753	Move constructor in draft
754	Ambiguous return clause for std::uninitialized_copy
755	std::vector and std:string lack explicit shrink-to-fit operations
756	Container adaptors push
757	Typo in the synopsis of vector
758	shared_ptr and nullptr
759	A reference is not an object
760	The emplace issue
761	unordered_map needs an at() member function
762	std::unique_ptr requires complete type?
763	Renaming emplace() overloads
764	equal_range on unordered containers should return a pair of local_iterators
765	More on iterator validity
766	Inconsistent exception guarantees between ordered and unordered associative containers
767	Forwarding and backward compatibility
768	Typos in [atomics]?
769	std::function should use nullptr_t instead of "unspecified-null-pointer-type"
770	std::function should use rvalue swap
771	Impossible throws clause in [string.conversions]
772	Impossible return clause in [string.conversions]
773	issues with random
774	Member swap undefined for most containers
775	Tuple indexing should be unsigned?
776	Undescribed assign function of std::array
777	Atomics Library Issue
778	std::bitset does not have any constructor taking a string literal
779	Resolution of #283 incomplete
780	std::merge() specification incorrect/insufficient
781	std::complex should add missing C99 functions
782	Extended seed_seq constructor is useless
783	thread::id reuse
784	unique_lock::release
785	[tr1] Random Number Requirements in TR1
786	Thread library timed waits, UTC and monotonic clocks
787	complexity of binary_search
788	Ambiguity in [istream.iterator]
789	xor_combine_engine(result_type) should be explicit
790	xor_combine::seed not specified
791	piecewise_constant_distribution::densities has wrong name
792	piecewise_constant_distribution is undefined for a range with just one endpoint
793	discrete_distribution missing constructor
794	piecewise_constant_distribution missing constructor
795	general_pdf_distribution should be dropped
796	ranlux48_base returns wrong value
797	ranlux48 returns wrong value
798	Refactoring of binders lead to interface breakage
799	Mersenne twister equality overspecified
800	Issues in 26.4.7.1 [rand.util.seedseq](6)
801	tuple and pair trivial members
802	knuth_b returns wrong value
803	Simplification of seed_seq::seq_seq
804	Some problems with classes error_code/error_condition
805	posix_error::posix_errno concerns
806	unique_ptr::reset effects incorrect, too permissive
807	tuple construction should not fail unless its element's construction fails
808	§[forward] incorrect redundant specification
809	std::swap should be overloaded for array types
810	Missing traits dependencies in operational semantics of extended manipulators
811	pair of pointers no longer works with literal 0
812	unsolicited multithreading considered harmful?
813	"empty" undefined for shared_ptr
814	vector<bool>::swap(reference, reference) not defined
815	std::function and reference_closure do not use perfect forwarding
816	Should bind()'s returned functor have a nofail copy ctor when bind() is nofail?
817	bind needs to be moved
818	wording for memory ordering
819	rethrow_if_nested
820	current_exception()'s interaction with throwing copy ctors
821	Minor cleanup : unique_ptr
822	Object with explicit copy constructor no longer CopyConstructible
823	identity<void> seems broken
824	rvalue ref issue with basic_string inserter
825	Missing rvalues reference stream insert/extract operators?
826	Equivalent of %'d, or rather, lack thereof?
827	constexpr shared_ptr::shared_ptr()?
828	Static initialization for std::mutex?
829	current_exception wording unclear about exception type
830	Incomplete list of char_traits specializations
831	wrong type for not_eof()
832	Applying constexpr to System error support
833	Freestanding implementations header list needs review for C++0x
834	unique_ptr::pointer requirements underspecified
835	Tying two streams together (correction to DR 581)
836	Effects of money_base::space and money_base::none on money_get
837	basic_ios::copyfmt() overly loosely specified
838	Can an end-of-stream iterator become a non-end-of-stream one?
839	Maps and sets missing splice operation
840	pair default template argument
841	cstdint.syn inconsistent with C99
842	ConstructibleAsElement and bit containers
843	Reference Closure
844	complex pow return type is ambiguous
845	atomics cannot support aggregate initialization
846	No definition for constructor
847	string exception safety guarantees
848	Missing std::hash specializations for std::bitset/std::vector<bool>
849	missing type traits to compute root class and derived class of types in a class hierachy
850	Should shrink_to_fit apply to std::deque?
851	simplified array construction
852	unordered containers begin(n) mistakenly const
853	to_string needs updating with zero and one
854	default_delete converting constructor underspecified
855	capacity() and reserve() for deque?
856	Removal of aligned_union
857	condition_variable::time_wait return bool error prone
858	Wording for Minimal Support for Garbage Collection
859	Monotonic Clock is Conditionally Supported?
860	Floating-Point State
861	Incomplete specification of EqualityComparable for std::forward_list
862	Impossible complexity for 'includes'
863	What is the state of a stream after close() succeeds
864	Defect in atomic wording
865	More algorithms that throw away information
866	Qualification of placement new-expressions
867	Valarray and value-initialization
868	Default construction and value-initialization
869	Bucket (local) iterators and iterating past end
870	Do unordered containers not support function pointers for predicate/hasher?
871	Iota's requirements on T are too strong
872	move_iterator::operator[] has wrong return type
873	signed integral type and unsigned integral type are not clearly defined
874	Missing initializer_list constructor for discrete_distribution
875	Missing initializer_list constructor for piecewise_constant_distribution
876	basic_string access operations should give stronger guarantees
877	to throw() or to Throw: Nothing.
878	forward_list preconditions
879	Atomic load const qualification
880	Missing atomic exchange parameter
881	shared_ptr conversion issue
882	duration non-member arithmetic requirements
883	swap circular definition
884	shared_ptr swap
885	pair assignment
886	tuple construction
887	issue with condition::wait_...
888	this_thread::yield too strong
889	thread::id comparisons
890	Improving <system_error> initialization
891	std::thread, std::call_once issue
892	Forward_list issues...
893	std::mutex issue
894	longjmp and destructors
895	"Requires:" on std::string::at et al
896	Library thread safety issue
897	Forward_list issues... Part 2
898	Small contradiction in n2723 to forward to committee
899	Adjusting shared_ptr for nullptr_t
900	Stream move-assignment
901	insert iterators can move from lvalues
902	Regular is the wrong concept to constrain numeric_limits
903	back_insert_iterator issue
904	result_of argument types
905	Mutex specification questions
906	ObjectType is the wrong concept to constrain initializer_list
907	Bitset's immutable element retrieval is inconsistently defined
908	Deleted assignment operators for atomic types must be volatile
909	regex_token_iterator should use initializer_list
910	Effects of MoveAssignable
911	I/O streams and move/swap semantic
912	Array swap needs to be conceptualized
913	Superfluous requirements for replace algorithms
914	Superfluous requirement for unique
915	minmax with initializer_list should return pair of T, not pair of const T&
916	Redundant move-assignment operator of pair should be removed
917	Redundant move-assignment operator of tuple should be removed
918	Swap for tuple needs to be conceptualized
919	(forward_)list specialized remove algorithms are over constrained
920	Ref-qualification support in the library
921	Rational Arithmetic should use template aliases
922	§[func.bind.place] Number of placeholders
923	atomics with floating-point
924	structs with internal padding
925	shared_ptr's explicit conversion from unique_ptr
926	Sequentially consistent fences, relaxed operations and modification order
927	Dereferenceable should be HasDereference
928	Wrong concepts used for tuple's comparison operators
929	Thread constructor
930	Access to std::array data as built-in array type
931	type trait extent<T, I>
932	unique_ptr(pointer p) for pointer deleter types
933	Unique_ptr defect
934	duration is missing operator%
935	clock error handling needs to be specified
936	Mutex type overspecified
937	Atomics for standard typedef types
938	default_delete<T[]>::operator() should only accept T*
939	Problem with std::identity and reference-to-temporaries
940	std::distance
941	Ref-qualifiers for assignment operators
942	Atomics synopsis typo
943	ssize_t undefined
944	atomic<bool> derive from atomic_bool?
945	system_clock::rep not specified
946	duration_cast improperly specified
947	duration arithmetic: contradictory requirements
948	ratio arithmetic tweak
949	owner_less
950	unique_ptr converting ctor shouldn't accept array form
951	Various threading bugs #1
952	Various threading bugs #2
953	Various threading bugs #3
954	Various threading bugs #4
955	Various threading bugs #5
956	Various threading bugs #6
957	Various threading bugs #7
958	Various threading bugs #8
959	Various threading bugs #9
960	Various threading bugs #10
961	Various threading bugs #11
962	Various threading bugs #12
963	Various threading bugs #13
964	Various threading bugs #14
965	Various threading bugs #15
966	Various threading bugs #16
967	Various threading bugs #17
968	Various threading bugs #18
969	What happened to Library Issue 475?
970	addressof overload unneeded
971	Spurious diagnostic conversion function
972	The term "Assignable" undefined but still in use
973	auto_ptr characteristics
974	duration<double> should not implicitly convert to duration<int>
975	is_convertible cannot be instantiated for non-convertible types
976	Class template std::stack should be movable
977	insert iterators inefficient for expensive to move types
978	Hashing smart pointers
979	Bad example
980	mutex lock() missing error conditions
981	Unordered container requirements should add initializer_list support
982	Wrong complexity for initializer_list assignment in Table 85
983	unique_ptr reference deleters should not be moved from
984	Does <cinttypes> have macro guards?
985	Allowing throwing move
986	Generic try_lock contradiction
987	reference_wrapper and function types
988	Reflexivity meaningless?
989	late_check and library
990	monotonic_clock::is_monotonic must be true
991	Provide allocator for wstring_convert
992	Allow implementations to implement C library in the global namespace
993	_Exit needs better specification
994	quick_exit should terminate well-defined
995	Operational Semantics Unclear
996	Move operation not well specified
997	"Effects: Equivalent to" is underspecified
998	Smart pointer referencing its owner
999	Taking the address of a function
1000	adjacent_find is over-constrained
1001	Pointers, concepts and headers
1002	Provide bulk include headers
1003	Require more useful headers for freestanding implementations
1004	Clarify "throws an exception"
1005	numeric_limits partial specializations not concept enabled
1006	operator delete in garbage collected implementation
1007	throw_with_nested not concept enabled
1008	nested_exception wording unclear
1009	InputIterator post-increment dangerous
1010	operator-= should use default in concept
1011	next/prev wrong iterator type
1012	reverse_iterator default ctor should value initialize
1013	Remove IsSameType hold-over constraints
1014	basic_regex should be created/assigned from initializer lists
1015	C++ programs - but not users - need to provide support concept_maps
1016	Provide LessThanComparable and EqualityComparable for FloatingPointType
1017	Floating-point types should not satisfy Regular
1018	Trait specifications should be expressed in terms of concepts
1019	Make integral_constant objects useable in integral-constant-expressions
1020	Restore aligned_union
1021	Allow nullptr_t assignments to unique_ptr
1022	Pointer-safety API has nothing to do with smart pointers
1023	Unclear inheritance relation for std::function
1024	std::function constructors overly generous
1025	The library should provide more specializations for std::hash
1026	Smart pointers need to be concept-constrained templates
1027	std::allocator needs to be a concept-constrained template
1028	raw_storage_iterator needs to be a concept-constrained template
1029	Specialized algorithms for memory management need to be concept-constrained templates
1030	Missing requirements for smart-pointer safety API
1031	Need shared_ptr conversion to a unique_ptr
1032	Tome utility templates need to be concept-constrained
1033	thread::join() effects?
1034	Clarify generality of Container Requirement tables
1035	<array>::swap can invalidate references, pointers, and iterators
1036	Remove iterator specification that is redundant due to concept constraints
1037	Unclear status of match_results as library container
1038	Sequence requirement table needs to reference several new containers
1039	Sequence container back function should also support const_iterator
1040	Clarify possible sameness of associative container's iterator and const_iterator
1041	Add associative/unordered container functions that allow to extract elements
1042	Provide ContiguousStorage concept and apply it to corresponding containers
1043	Clarify that compare_exchange is not a read-modify-write operation
1044	Empty tag types should be constexpr literals
1045	Remove unnecessary preconditions from unique_lock constructor
1046	Provide simple facility to start asynchronous operations
1047	Ensure that future's get() blocks when not ready
1048	Provide empty-state inspection for std::unique_future
1049	Move assignment of promise inverted
1050	Clarify postconditions for get_future()
1051	Specify subscript operation return types of reverse_iterator and move_iterator
1052	reverse_iterator::operator-> should also support smart pointers
1053	Unify algorithms with operator and function object variants
1054	forward broken
1055	Provide a trait that returns the underlying type of an enumeration type
1056	Must all Engines and Distributions be Streamable?
1057	RandomNumberEngineAdaptor
1058	New container issue
1059	Usage of no longer existing FunctionType concept
1060	Embedded nulls in NTBS
1061	Bad indexing for tuple access to pair (Editorial?)
1062	Missing insert_iterator for stacks/queues
1063	03 iterator compatibilty
1064	Term "object state" should not refer to classes
1065	Allow inline namespaces within namespace std for implementations
1066	Use [[noreturn]] attribute in the library
1067	simplified wording for inner_product
1068	class random_device should be movable
1069	class seed_seq should support efficient move operations
1070	Ambiguous move overloads in function
1071	is_bind_expression should derive from integral_constant<bool>
1072	Is std::hash a constrained template or not?
1073	Declaration of allocator_arg should be constexpr
1074	concept map broken by N2840
1075	Scoped allocators are too complex
1076	unary/binary_negate need constraining and move support
1077	Nonesense tuple declarations
1078	DE-17: Remove class type_index
1079	UK-265: RandomAccessIterator's operator- has nonsensical effects clause
1080	Concept ArithmeticLike should provide explicit boolean conversion
1081	basic_string needs to be a concept-constrained template
1082	codecvt needs to be a concept-constrained template
1083	InputIterator and OutputIterator template parameters need to be concept constraints
1084	Concept ForwardIterator should provide default implementation for post-increment
1085	BidirectionalIterator concept should provide default implementation for post-decrement
1086	Stream iterators need to be concept-constrained templates
1087	Incorrect OutputIterator concept requirements for replace algorithms
1088	std::promise should provide non-member swap overload
1089	Unify "Throws: Nothing." specifications
1090	Missing description of packaged_task member swap, missing non-member swap
1091	Multimap description confusing
1092	Class template integral_constant should be a constrained template
1093	Multiple definitions for random_shuffle algorithm
1094	Replace "unspecified-bool-type" by "explicit operator bool() const" in I/O library
1095	Shared objects and the library wording unclear
1096	unconstrained rvalue ref parameters
1097	#define __STDCPP_THREADS
1098	definition of get_pointer_safety()
1099	Various issues
1100	auto_ptr to unique_ptr conversion
1101	unique requirements
1102	std::vector's reallocation policy still unclear
1103	system_error constructor postcondition overly strict
1104	basic_ios::move should accept lvalues
1105	Shouldn't Range be an auto concept
1106	Multiple exceptions from connected shared_future::get()?
1107	constructor shared_future(unique_future) by value?
1108	thread.req.exception overly constrains implementations
1109	std::includes should require CopyConstructible predicate
1110	Is for_each overconstrained?
1111	associative containers underconstrained
1112	bitsets and new style for loop
1113	bitset::to_string could be simplified
1114	Type traits underspecified
1115	va_copy missing from Standard macros table
1116	Literal constructors for tuple
1117	tuple copy constructor
1118	tuple query APIs do not support cv-qualification
1119	tuple query APIs do not support references
1120	New type trait - remove_all
1121	Support for multiple arguments
1122	Ratio values should be constexpr
1123	No requirement that standard streams be flushed
1124	Invalid definition of concept RvalueOf
1125	ostream_iterator does not work with movable types
1126	istreambuff_iterator::equal needs a const & parameter
1127	rvalue references and iterator traits
1128	Missing definition of iterator_traits<T*>
1129	istream(buf)_iterator should support literal sentinel value
1130	copy_exception name misleading
1131	C++0x does not need alignment_of
1132	JP-30: nested exceptions
1133	Does N2844 break current specification of list::splice?
1134	Redundant specification of <stdint.h>, <fenv.h>, <tgmath.h>, and maybe <complex.h>
1135	exception_ptr should support contextual conversion to bool
1136	Incomplete specification of nested_exception::rethrow_nested()
1137	Return type of conj and proj
1138	Unusual return value for operator+
1139	Thread support library not concept enabled
1140	Numerics library not concept enabled
1141	Input/Output library not concept enabled
1142	Regular expressions library not concept enabled
1143	Atomic operations library not concept enabled
1144	"thread safe" is undefined
1145	Inappropriate headers for atomics
1146	"lockfree" does not say enough
1147	Non-volatile atomic functions
1148	Wrong argument type of I/O stream manipulators setprecision() and setw()
1149	Reformulating NonemptyRange axiom
1150	wchar_t, char16_t and char32_t filenames
1151	Behavior of the library in the presence of threads is incompletely specified
1152	Expressions parsed differently than intended
1153	Standard library needs review for constructors to be explicit to avoid treatment as initializer-list constructor
1154	complex should accept integral types
1155	Reference should be to C99
1156	Constraints on bitmask and enumeration types to be tightened
1157	Local types can now instantiate templates
1158	Encouragement to use monotonic clock
1159	Unclear spec for resource_deadlock_would_occur
1160	future_error public constructor is 'exposition only'
1161	Unnecessary unique_future limitations
1162	shared_future should support an efficient move constructor
1163	shared_future is inconsistent with shared_ptr
1164	promise::swap should pass by rvalue reference
1165	Unneeded promise move constructor
1166	Allocator-specific move/copy break model of move-constructor and move-assignment
1167	pair<T,U> doesn't model LessThanComparable in unconstrained code even if T and U do.
1168	Odd wording for bitset equality operators
1169	num_get not fully compatible with strto*
1170	String char-like types no longer PODs
1171	duration types should be literal
1172	select_on_container_(copy|move)_construction over-constrained
1173	"Equivalence" wishy-washiness
1174	Type property predicates
1175	unordered complexity
1176	Make thread constructor non-variadic
1177	Improve "diagnostic required" wording
1178	Header dependencies
1179	Probably editorial in [structure.specifications]
1180	Missing string_type member typedef in class sub_match
1181	Invalid sub_match comparison operators
1182	Unfortunate hash dependencies
1183	basic_ios::set_rdbuf may break class invariants
1184	Feature request: dynamic bitset
1185	Iterator categories and output iterators
1186	Forward list could model a stack
1187	std::decay
1188	Unordered containers should have a minimum load factor as well as a maximum
1189	Awkward interface for changing the number of buckets in an unordered associative container
1190	Setting the maximum load factor should return the previous value
1191	tuple get API should respect rvalues
1192	basic_string missing definitions for cbegin / cend / crbegin / crend
1193	default_delete cannot be instantiated with incomplete types
1194	Unintended queue constructor
1195	"Diagnostic required" wording is insufficient to prevent UB
1196	move semantics undefined for priority_queue
1197	Can unordered containers have bucket_count() == 0?
1198	Container adaptor swap: member or non-member?
1199	Missing extended copy constructor in container adaptors
1200	"surprising" char_traits<T>::int_type requirements
1201	Do we always want to unwrap ref-wrappers in make_tuple
1202	integral_constant needs a spring clean
1203	More useful rvalue stream insertion
1204	Global permission to move
1205	Some algorithms could more clearly document their handling of empty ranges
1206	Incorrect requires for move_backward and copy_backward
1207	Underspecified std::list operations?
1208	valarray initializer_list constructor has incorrect effects
1209	match_results should be moveable
1210	Iterator reachability should not require a container
1211	Move iterators should be restricted as input iterators
1212	result of post-increment/decrement operator
1213	Meaning of valid and singular iterator underspecified
1214	Insufficient/inconsistent key immutability requirements for associative containers
1215	list::merge with unequal allocators
1216	LWG 1066 Incomplete?
1217	Quaternion support
1218	mutex destructor synchronization
1219	unique_lock::lock and resource_deadlock_would_occur
1220	What does condition_variable wait on?
1221	condition_variable wording
1222	condition_variable incorrect effects for exception safety
1223	condition_variable_any lock matching?
1224	condition_variable_any support for recursive mutexes?
1225	C++0x result_of issue
1226	Incomplete changes of #890
1227	<bitset> synopsis overspecified
1228	User-specialized nothrow type traits
1229	error_code operator= typo
1230	mem_fn and variadic templates
1231	weak_ptr comparisons incompletely resolved
1232	Still swap's with rvalue-references
1233	Missing unique_ptr signatures in synopsis
1234	"Do the right thing" and NULL
1235	Issue with C++0x random number proposal
1236	reserved identifiers in programs not using the library
1237	Constrained error_code/error_condition members
1238	Defining algorithms taking iterator for range
1239	Defect report
1240	Deleted comparison functions of std::function not needed
1241	unique_copy needs to require EquivalenceRelation
1242	Enable SCARY iterators
1243	Missing operator+= (initializer_list<T>) for valarray
1244	wait_*() in *future for synchronous functions
1245	std::hash<string> & co
1246	vector::resize() missing efficiency guarantee
1247	auto_ptr is overspecified
1248	Equality comparison for unordered containers
1249	basic_ios default ctor
1250	<bitset> still overspecified
1251	move constructing basic_stringbuf
1252	wbuffer_convert::state_type inconsistency
1253	invalidation of iterators and emplace vs. insert inconsistence in assoc. containers
1254	Misleading sentence in vector<bool>::flip
1255	declval should be added to the library
1256	weak_ptr comparison functions should be removed
1257	Header <ios> still contains a concept_map
1258	std::function Effects clause impossible to satisfy
1259	Should initializer-list constructors move elements?
1260	is_constructible<int*,void*> reports true
1261	Insufficent overloads for to_string / to_wstring
1262	std::less<std::shared_ptr<T>> is underspecified
1263	missing swap overloads for regex
1264	quick_exit support for freestanding implementations
1265	longjmp and destructors
1266	shared_future::get and deferred async functions
1267	Incorrect wording for condition_variable_any::wait_for
1268	The Mutex requirements in 30.4.1 and 30.4.2 are wrong
1269	Associated state doesn't account for async
1270	result_of should be moved to <type_traits>
1271	CR undefined in duration operators
1272	confusing declarations of promise::set_value
1273	future::valid should be callable on an invalid future
1274	atomic_future constructor
1275	Creating and setting futures
1276	forwardlist missing allocator constructors
1277	std::thread::id should be trivially copyable
1278	Inconsistent return values for forward_list::insert_after
1279	forbid [u|bi]nary_function specialization
1280	Initialization of stream iterators
1281	CopyConstruction and Assignment between ratios having the same normalized form
1282	A proposal to add std::split algorithm
1283	MoveConstructible and MoveAssignable need clarification of moved-from state
1284	vector<bool> initializer_list constructor missing an allocator argument
1285	allocator_traits call to new
1286	allocator_traits::select_on_container_copy_construction type-o
1287	std::function requires CopyConstructible target object
1288	std::function assignment from rvalues
1289	Generic casting requirements for smart pointers
1290	Don't require [u|bi]nary_function inheritance
1291	Exceptions thrown during promise::set_value
1292	std::function should support all callable types
1293	unique_ptr<T[], D> needs to get rid of unspecified-pointer-type
1294	Difference between callable wrapper and forwarding call wrapper unclear
1295	Contradictory call wrapper requirements
1296	map and multimap value_compare overspecified
1297	unique_ptr's relational operator functions should induce a total order
1298	Missing specialization of ctype_byname<char>
1299	Confusing typo in specification for get_time
1300	Circular definition of promise::swap
1301	clear() and assignment
1302	different emplace semantics for sequence and associated containers
1303	shared_ptr, unique_ptr, and rvalue references v2
1304	Missing preconditions for shared_future
1305	preconditions for atomic_future
1306	pointer and const_pointer for <array>
1307	exception_ptr and allocator pointers don't understand !=
1308	Concerns about initializer_list overloads of min, max, and minmax
1309	Missing expressions for Move/CopyConstructible
1310	forward_list splice_after from lvalues
1311	multi-pass property of Forward Iterator underspecified
1312	vector::data no longer returns a raw pointer
1313	Seed sequence's param function not useful for pure output iterator
1314	NULL and nullptr
1315	return type of async
1316	scoped_allocator_adaptor operator== has no definition
1317	make_hash
1318	N2982 removes previous allocator capabilities
1319	Containers should require an iterator that is at least a Forward Iterator
1320	Header for iter_swap
1321	scoped_allocator_adaptor construct and destroy don't use allocator_traits
1322	Explicit CopyConstructible requirements are insufficient
1323	basic_string::replace should use const_iterator
1324	Still too many implicit conversions for pair and tuple
1325	bitset
1326	Missing/wrong preconditions for pair and tuple functions
1327	templates defined in <cmath> replacing C macros with the same name
1328	istream extractors not setting failbit if eofbit is already set
1329	Data races on vector<bool>
1330	Move container requirements into requirements tables
1331	incorporate move special member functions into library
1332	Let Hash objects throw!
1333	Missing forwarding during std::function invocation
1334	Insert iterators are broken for some proxy containers compared to C++03
1335	Insufficient requirements for tuple::operator<()
1336	Conflicting Error Conditions for packaged_task::operator()
1337	Swapped arguments in regex_traits::isctype
1338	LWG 1205 incorrectly applied
1339	uninitialized_fill_n should return the end of its range
1340	Why does forward_list::resize take the object to be copied by value?
1341	Reporting out-of-bound values on numeric string conversions
1342	is_* traits for binding operations can't be meaningfully specialized
1343	unexpected output required of strings
1344	Replace throw() with noexcept
1345	Library classes should have noexcept move operations
1346	Apply noexcept where library specification does not permit exceptions
1347	Apply noexcept judiciously throughout the library
1348	Exception safety of unspecified types
1349	swap should not throw
1350	Implicit contructors accidentally made some library types move-only
1351	Replace dynamic exception specifications with noexcept
1352	Apply noexcept where library specification says "Throws: Nothing"
1353	Clarify the state of a moved-from object
1354	The definition of deadlock excludes cases involving a single thread
1355	The definition of move-assignment operator is redundant
1356	The definition of move-constructor is redundant
1357	Library bitmask types to not satisfy the bimask type requirements
1358	Add <chrono> and <ratio> to freestanding implementations
1359	Add <tuple> and <utility> to freestanding implementations
1360	Add <atomic> to free-standing implementations
1361	Does use of std::size_t in a header imply that typedef name is available to users?
1362	Description of binding to rvalue-references should use the new 'xvalue' vocabulary
1363	offsetof should be marked noexcept
1364	It is not clear how exception_ptr is synchronized
1365	Thread-safety of handler functions
1366	New-handler and data races
1367	Deprecate library support for checking dynamic exception specifications
1368	Thread safety of std::uncaught_exception()
1369	rethrow_exception may introduce data races
1370	throw_with_nested should not use perfect forwarding
1371	Standard exceptions require stronger no-throw guarantees
1372	Adopt recommended practice for standard error categories
1373	Customizable traits should have their own headers
1374	Clarify moved-from objects are "toxic"
1375	reference_type should not have been removed from the allocator requirements
1376	Allocator interface is not backward compatible
1377	The revised forward is not compatible with access-control
1378	pair and tuple have too many conversions
1379	pair copy-assignment not consistent for references
1380	pair and tuple of references need to better specify move-semantics
1381	Replace pair's range support by proper range facility
1382	pair and tuple constructors should forward arguments
1383	Inconsistent defaulted move/copy members in pair and tuple
1384	Function pack_arguments is poorly named
1385	tuple_cat should be a single variadic signature
1386	pack_arguments overly complex
1387	Range support by tuple should be removed
1388	LWG 1281 incorrectly accepted
1389	Compile-time rational arithmetic and overflow
1390	Limit speculative compilation for constructible/convertible traits
1391	constructible/convertible traits and access control
1392	result_of should support pointer-to-data-member
1393	Trivial traits imply noexcept
1394	is_constructible reports false positives
1395	Inconsistent reference links should be unified
1396	regex should support allocators
1397	Deprecate '98 binders
1398	Users should be able to specialize functors without depending on whole <functional> header
1399	function does not need an explicit default constructor
1400	FCD function does not need an explicit default constructor
1401	Provide support for unique_ptr<T> == nullptr
1402	nullptr constructors for smart pointers should be constexpr
1403	Inconsistent definitions for allocator_arg
1404	pointer_traits should have a size_type member
1405	Move scoped_allocator_adaptor into separate header
1406	Support hashing smart-pointers based on owner
1407	Synch shared_ptr constructors taking movable types
1408	Allow recycling of pointers after undeclare_no_pointers
1409	Specify whether monotonic_clock is a distinct type or a typedef
1410	Add a feature-detect macro for monotonic_clock
1411	Add a compile-time flag to detect monotonic_clock
1412	Make monotonic clocks mandatory
1413	Specify whether high_resolution_clock is a distinct type or a typedef
1414	Fixing remaining dead links to POS_T and OFF_T
1415	Iterator stability bans the short-string optimization
1416	forward_list::erase_after should not be allowed to throw
1417	front/back on a zero-sized array should be undefined
1418	Effects of resize(size()) on a deque
1419	forward_list::erase_after should return an iterator
1420	Effects of resize(size()) on a list
1421	Accidental move-only library types due to new core language rules
1422	vector<bool> iterators are not random access
1423	map constructor accepting an allocator as single parameter should be explicit
1424	multimap constructor accepting an allocator as a single parameter should be explicit
1425	set constructor accepting an allocator as a single parameter should be explicit
1426	multiset constructor accepting an allocator as a single parameter should be explicit
1427	unordered_map constructor accepting an allocator as a single parameter should be explicit
1428	unordered_multimap constructor accepting an allocator as a single parameter should be explicit
1429	unordered_set constructor accepting an allocator as a single parameter should be explicit
1430	unordered_multiset constructor accepting an allocator as a single parameter should be explicit
1431	is_permutation must be more restrictive
1432	random_shuffle signatures are inconsistent
1433	random_shuffle and shuffle should have consistent signatures
1434	For min/max functions replace variadic arguments by initializer_list argument
1435	Unclear returns specifications for C99 complex number functions
1436	Random number engine constructor concerns
1437	Mersenne twister meaningless for word sizes less than two
1438	No definition for base()
1439	Return from densities() functions?
1440	Incorrect specification for piecewise_linear_distribution
1441	Floating-point test functions are incorrectly specified
1442	"happens-before" should be "synchronizes-with"
1443	Imposed happens-before edges are not made transitive
1444	OFF_T is not defined
1445	Several iostreams member functions incorrectly specified
1446	Move and swap for I/O streams
1447	Request to resolve issue LWG 1328
1448	Concerns about basic_stringbuf::str(basic_string) postconditions
1449	Incomplete specification of header <cinttypes>
1450	Contradiction in regex_constants
1451	regex should support allocators
1452	"target sequence" is not defined
1453	Default constructed match_results behavior for certain operations
1454	Ensure C compatibility for atomics
1455	C language compatibility for atomics
1456	Missing fixed-size atomic_ typedefs
1457	Splitting lock-free properties
1458	Overlapping evaluations are allowed
1459	Overlapping evaluations are allowed
1460	Missing lock-free property for type bool should be added
1461	Rename all ATOMIC_* macros as STD_ATOMIC_*
1462	Ambiguous value assignment to atomic_bool
1463	Inconsistent value assignment for atomic_bool
1464	Underspecified typedefs for atomic integral types
1465	Missing arithmetic operators for atomic_address
1466	Silent const breakage by compare_exchange_* member functions
1467	Deriving atomic<T*> from atomic_address breaks type safety
1468	atomic_address::compare_exchange_* member functions should match atomic_compare_exchange_* free functions
1469	atomic<T*> inheritance from atomic_address breaks type safety
1470	"Same-ness" curiosities
1471	Default constructor of atomics needs specification
1472	Incorrect semantics of atomic_init
1473	Incomplete memory order specifications
1474	weak compare-and-exchange confusion
1475	weak compare-and-exchange confusion II
1476	Meaningless specification of spurious failure
1477	weak compare-and-exchange confusion III
1478	Clarify race conditions in atomics initialization
1479	Fence functions should be extern "C"
1480	Atomic fences don't have synchronizes with relation
1481	Missing Lockable requirements
1482	Timeout operations are under-specified
1483	__STDCPP_THREADS spelling
1484	Need a way to join a thread with a timeout
1485	Unclear thread::id specification
1486	Value of this_thread::get_id() underspecified for detached thread
1487	Clock related operations exception specifications conflict
1488	Improve interoperability between the C++0x and C1x threads APIs
1489	unlock functions and unlock mutex requirements are inconsistent
1490	Mutex requirements too stringent
1491	try_lock does not guarantee forward progress
1492	Mutex requirements should not be bound to threads
1493	Add mutex, recursive_mutex, is_locked function
1494	Term "are serialized" not defined
1495	Condition variable wait_for return value insufficient
1496	condition_variable not implementable
1497	lock() postcondition can not be generally achieved
1498	Unclear specification for [thread.condition]
1499	Condition variables preclude wakeup optimization
1500	Consider removal of native_handle()
1501	Specification for managing associated asynchronous state has problems
1502	Specification of [futures.state] unclear
1503	"associated asynchronous state" must go
1504	Term "are serialized" is not defined
1505	Synchronization between promise::set_value and future::get
1506	set_exception with a null pointer
1507	promise::XXX_at_thread_exit functions have no synchronization requirements
1508	Rename packaged_task::operator bool()
1509	No restriction on calling future::get more than once
1510	Should be undefined behaviour to call atomic_future operations unless valid()
1511	Synchronize the move-constructor for atomic_future
1512	Conflict in specification: block or join?
1513	'launch' enum too restrictive
1514	packaged_task constructors need review
1515	packaged_task::make_ready_at_thread_exit has no synchronization requirements
1516	No specification for which header contains auto_ptr
1517	default_delete's default constructor should be trivial
1518	Waiting for deferred functions
1519	bucketsize() const only for unordered set
1520	INVOKE on member data pointer with too many arguments
1521	Requirements on internal pointer representations in containers
1522	conj specification is now nonsense
1523	noexcept for Clause 29
1524	Allocation functions are missing happens-before requirements and guarantees
1525	Effects of resize(size()) on a vector
1526	C++ should not impose thread safety requirements on C99 library implementations
2000	Missing definition of packaged_task specialization of uses_allocator
2001	Class template basic_regex uses non existent string_type
2002	Class template match_results does not specify the semantics of operator==
2003	String exception inconsistency in erase.
2004	duration::operator* has template parameters in funny order
2005	unordered_map::insert(T&&) protection should apply to map too
2006	emplace broken for associative containers
2007	Incorrect specification of return value for map<>::at()
2008	Conflicting Error Conditions for packaged_task::operator()
2009	Reporting out-of-bound values on numeric string conversions
2010	is_* traits for binding operations can't be meaningfully specialized
2011	Unexpected output required of strings
2012	Associative maps should insert pair, not tuple
2013	Do library implementers have the freedom to add constexpr?
2014	More restrictions on macro names
2015	Incorrect pre-conditions for some type traits
2016	Allocators must be no-throw swappable
2017	std::reference_wrapper makes incorrect usage of std::result_of
2018	[CD] regex_traits::isctype Returns clause is wrong
2019	isblank not supported by std::locale
2020	Time utility arithmetic constexpr functions have invalid effects
2021	Further incorrect usages of result_of
2022	reference_wrapper<T>::result_type is underspecified
2023	Incorrect requirements for lock_guard and unique_lock
2024	Inconsistent implementation requirements for atomic<integral> and atomic<T*>
2025	Incorrect semantics of move assignment operator of packaged_task
2026	hash should be std qualified for unordered container
2027	Initialization of the stored task of a packaged_task
2028	messages_base::catalog overspecified
2029	Missing 'noexcept' on basic_regex move-assignment operator
2030	packaged_task::result_type should be removed
2031	std::future<>::share() only applies to rvalues
2032	Incorrect synchronization clause of async function
2033	Preconditions of reserve, shrink_to_fit, and resize functions
2034	Initialization of atomics is misspecified so that it doesn't preserve sequential consistency
2035	Output iterator requirements are broken
2036	istream >> char and eofbit
2037	atomic free functions incorrectly specified
2038	Missing definition for incrementable iterator
2039	Issues with std::reverse and std::copy_if
2040	Missing type traits related to is_convertible
2041	Stage 2 accumulate incompatibilty
2042	Comparing forward_list::before_begin() to forward_list::end()
2043	std{in,out,err} should be usable as field names
2044	No definition of "Stable" for copy algorithms
2045	forward_list::merge and forward_list::splice_after with unequal allocators
2046	shared_future(future<R>&&) should be allowed to throw
2047	Incorrect "mixed" move-assignment semantics of unique_ptr
2048	Unnecessary mem_fn overloads
2049	is_destructible is underspecified
2050	Unordered associative containers do not use allocator_traits to define member types
2051	Explicit tuple constructors for more than one parameter
2052	Mixup between mapped_type and value_type for associative containers
2053	Errors in regex bitmask types
2054	time_point constructors need to be constexpr
2055	std::move in std::accumulate and other algorithms
2056	future_errc enums start with value 0 (invalid value for broken_promise)
2057	time_point + duration semantics should be made constexpr conforming
2058	valarray and begin/end
2059	C++0x ambiguity problem with map::erase
2060	unique_ptr<T[]>(nullptr_t) missing noexcept
2061	make_move_iterator and arrays
2062	Effect contradictions w/o no-throw guarantee of std::function swaps
2063	Contradictory requirements for string move assignment
2064	More noexcept issues in basic_string
2065	Minimal allocator interface
2066	Missing specification of vector::resize(size_type)
2067	packaged_task should have deleted copy c'tor with const parameter
2068	std::pair not C++03-compatible with defaulted copy c'tor
2069	Inconsistent exception spec for basic_string move constructor
2070	allocate_shared should use allocator_traits<A>::construct
2071	std::valarray move-assignment
2072	Unclear wording about capacity of temporary buffers
2073	Library exceptions that take string arguments
2074	Off by one error in std::reverse_copy
2075	Progress guarantees, lock-free property, and scheduling assumptions
2076	Bad CopyConstructible requirement in set constructors
2077	Further incomplete constraints for type traits
2078	Throw specification of async() incomplete
2079	Required pow() overloads
2080	Specify when once_flag becomes invalid
2081	Allocator requirements should include CopyConstructible
2082	Misleading complexity requirements in <algorithm>
2083	const-qualification on weak_ptr::owner_before
2084	basic_string use of charT*
2085	Wrong description of effect 1 of basic_istream::ignore
2086	Overly generic type support for math functions
2087	iostream_category() and noexcept
2088	std::terminate problem
2089	std::allocator::construct should use uniform initialization
2090	Minor Overconstraint in Mutex Types
2091	Misplaced effect in m.try_lock_for()
2092	Vague Wording for condition_variable_any
2093	Throws clause of condition_variable::wait with predicate
2094	duration conversion overflow shouldn't participate in overload resolution
2095	promise and packaged_task missing constructors needed for uses-allocator construction
2096	Incorrect constraints of future::get in regard to MoveAssignable
2097	packaged_task constructors should be constrained
2098	Minor Inconsistency between promise::set_value and promise::set_value_at_thread_exit
2099	Unnecessary constraints of va_start() usage
2100	timed waiting functions cannot timeout if launch::async policy used
2101	Some transformation types can produce impossible types
2102	Why is std::launch an implementation-defined type?
2103	std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment
2104	unique_lock move-assignment should not be noexcept
2105	Inconsistent requirements on const_iterator's value_type
2106	move_iterator wrapping iterators returning prvalues
2107	Some iterator category should guarantee the lifetime of references
2108	No way to identify allocator types that always compare equal
2109	Incorrect requirements for hash specializations
2110	remove can't swap but note says it might
2111	Which unexpected/terminate handler is called from the exception handling runtime?
2112	User-defined classes that cannot be derived from
2113	Do library implementers have the freedom to add final to non-polymorphic components?
2114	Incorrect "contextually convertible to bool" requirements
2115	Undefined behaviour for valarray assignments with mask_array index?
2116	is_nothrow_constructible and destructors
2117	ios_base manipulators should have showgrouping/noshowgrouping
2118	[CD] unique_ptr for array does not support cv qualification conversion of actual argument
2119	Missing hash specializations for extended integer types
2120	What should async do if neither 'async' nor 'deferred' is set in policy?
2121	app for string streams
2122	merge() stability for lists versus forward lists
2123	merge() allocator requirements for lists versus forward lists
2124	Seed sequence over-specified
2125	TimedMutex specification problem
2126	Several specification problems in regard to mutex requirements
2127	Move-construction with raw_storage_iterator
2128	Absence of global functions cbegin/cend
2129	User specializations of std::initializer_list
2130	Missing ordering constraints
2131	Member function getline taking a string as parameter
2132	std::function ambiguity
2133	Attitude to overloaded comma for iterators
2134	Redundant Mutex requirement?
2135	Unclear requirement for exceptions thrown in condition_variable::wait()
2136	Postconditions vs. exceptions
2137	Misleadingly constrained post-condition in the presence of exceptions
2138	atomic_flag::clear should not accept memory_order_consume
2139	What is a user-defined type?
2140	Meaning of notify_all_at_thread_exit synchronization requirement?
2141	common_type trait produces reference types
2142	packaged_task::operator() synchronization too broad?
2143	ios_base::xalloc should be thread-safe
2144	Missing noexcept specification in type_index
2145	error_category default constructor
2146	Are reference types Copy/Move-Constructible/Assignable or Destructible?
2147	Unclear hint type in Allocator's allocate function
2148	Hashing enums should be supported directly by std::hash
2149	Concerns about 20.8/5
2150	Unclear specification of find_end
2151	basic_string<>::swap semantics ignore allocators
2152	Instances of standard container types are not swappable
2153	Narrowing of the non-member swap contract
2154	What exactly does compile-time complexity imply?
2155	Macro __bool_true_false_are_defined should be removed
2156	Unordered containers' reserve(n) reserves for n-1 elements
2157	How does std::array<T,0> initialization work when T is not default-constructible?
2158	Conditional copy/move in std::vector
2159	atomic_flag initialization
2160	Unintended destruction ordering-specification of resize
2161	const equivalence of std::map
2162	allocator_traits::max_size missing noexcept
2163	nth_element requires inconsistent post-conditions
2164	What are the semantics of vector.emplace(vector.begin(), vector.back())?
2165	std::atomic<X> requires X to be nothrow default constructible
2166	Heap property underspecified?
2167	Copy assignment requirements of Containers
2168	Inconsistent specification of uniform_real_distribution constructor
2169	Missing reset() requirements in unique_ptr specialization
2170	Aggregates cannot be DefaultConstructible
2171	"swappable" undefined for swapping lvalue and rvalue
2172	Does atomic_compare_exchange_* accept v == nullptr arguments?
2173	The meaning of operator + in the description of the algorithms
2174	wstring_convert::converted() should be noexcept
2175	wstring_convert and wbuffer_convert validity
2176	Special members for wstring_convert and wbuffer_convert
2177	Requirements on Copy/MoveInsertable
2178	Allocator requirement changes not mentioned Annex C
2179	enable_shared_from_this and construction from raw pointers
2180	Exceptions from std::seed_seq operations
2181	Exceptions from seed sequence operations
2182	Container::[const_]reference types are misleadingly specified
2183	Muddled allocator requirements for match_results constructors
2184	Muddled allocator requirements for match_results assignments
2185	Missing throws clause for future/shared_future::wait_for/wait_until
2186	Incomplete action on async/launch::deferred
2187	vector<bool> is missing emplace and emplace_back member functions
2188	Reverse iterator does not fully support targets that overload operator&
2189	Throwing swap breaks unordered containers' state
2190	Condition variable specification
2191	Incorrect specification of match_results(match_results&&)
2192	Validity and return type of std::abs(0u) is unclear
2193	Default constructors for standard library containers are explicit
2194	Impossible container requirements for adaptor types
2195	Missing constructors for match_results
2196	Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types
2197	Specification of is_[un]signed unclear for non-arithmetic types
2198	max_load_factor(z) makes no strong guarantees, but bans useful behavior
2199	unordered containers are required to have an initial max load factor of 1.0
2200	Data race avoidance for all containers, not only for sequences
2201	Missing macro entries from C standard library
2202	Missing allocator support by async
2203	scoped_allocator_adaptor uses wrong argument types for piecewise construction
2204	reverse_iterator should not require a second copy of the base iterator
2205	Problematic postconditions of regex_match and regex_search
2206	Inaccuracy in initializer_list constructor requirements
2207	basic_string::at should not have a Requires clause
2208	std::reverse_iterator should be a literal type
2209	assign() overspecified for sequence containers
2210	Missing allocator-extended constructor for allocator-aware containers
2211	Replace ambiguous use of "Allocator" in container requirements
2212	tuple_size for const pair request <tuple> header
2213	Return value of std::regex_replace
2214	Clarify basic_ios::init call restrictions
2215	(unordered) associative container functors should be CopyConstructible
2216	regex_replace(basic_string) allocator handling
2217	operator==(sub_match, string) slices on embedded '\0's
2218	Unclear how containers use allocator_traits::construct()
2219	INVOKE-ing a pointer to member with a reference_wrapper as the object expression
2220	Under-specification of operator== for regex_token_iterator
2221	No formatted output operator for nullptr
2222	Inconsistency in description of forward_list::splice_after single-element overload
2223	shrink_to_fit effect on iterator validity
2224	Ambiguous status of access to non-live objects
2225	Unrealistic header inclusion checks required
2226	wstring_convert methods do not take allocator instance
2227	Stateful comparison objects in associative containers
2228	Missing SFINAE rule in unique_ptr templated assignment
2229	Standard code conversion facets underspecified
2230	"see below" for initializer-list constructors of unordered containers
2231	DR 704 removes complexity guarantee for clear()
2232	[CD] The char_traits specializations should declare their length(), compare(), and find() members constexpr
2233	bad_function_call::what() unhelpful
2234	assert() should allow usage in constant expressions
2235	Undefined behavior without proper requirements on basic_string constructors
2236	kill_dependency unconditionally noexcept
2237	<cuchar> macros
2238	Problematic iterator-pair constructor of containers
2239	min/max/minmax requirements
2240	Probable misuse of term "function scope" in [thread.condition]
2241	<cstdalign> and #define of alignof
2242	[uninitialized_]copy_n() defect
2243	istream::putback problem
2244	Issue on basic_istream::seekg
2245	packaged_task::reset() memory allocation
2246	unique_ptr assignment effects w.r.t. deleter
2247	Type traits and std::nullptr_t
2248	numeric_limits::is_iec559 misnamed
2249	[CD] Remove gets from <cstdio>
2250	Follow-up On Library Issue 2207
2251	C++ library should define ssize_t
2252	Strong guarantee on vector::push_back() still broken with C++11?
2253	[arrays.ts] dynarray should state which container requirements aren't met
2254	[arrays.ts] Is dynarray an allocator-aware container?
2255	[arrays.ts] dynarray constructor ambiguity
2256	On vector iterator invalidation
2257	Simplify container requirements with the new algorithms
2258	a.erase(q1, q2) unable to directly return q2
2259	Issues in 17.6.5.5 rules for member functions
2260	Missing requirement for Allocator::pointer
2261	Are containers required to use their 'pointer' type internally?
2262	Requirement for unique_ptr<T>::get_deleter()(p) to be able to destroy the unique_ptr
2263	Comparing iterators and allocator pointers with different const-character
2264	[arrays.ts] std::dynarray defines its initializer-list constructor in terms of a non-existent constructor
2265	29.3p9 appears to rule out some acceptable executions
2266	vector and deque have incorrect insert requirements
2267	partial_sort_copy underspecified for ranges of two different types
2268	Setting a default argument in the declaration of a member function assign of std::basic_string
2269	Container iterators and argument-dependent lookup
2270	Inconsistent to_string overloads
2271	regex_traits::lookup_classname specification unclear
2272	quoted should use char_traits::eq for character comparison
2273	regex_match ambiguity
2274	Does map::operator[] value-initialize or default-insert a missing element?
2275	[CD] Why is forward_as_tuple not constexpr?
2276	Missing requirement on std::promise::set_exception
2277	[arrays.ts] <dynarray> is missing in 24.7/1
2278	User-defined literals for Standard Library types
2279	Carefully state effects of list::splice function
2280	begin/end for arrays should be constexpr and noexcept
2281	C99 cross-reference typo in [using.linkage]
2282	[fund.ts] Incorrect is_assignable constraint in optional::op=(U&&)
2283	[fund.ts] optional declares and then does not define an operator<()
2284	Inconsistency in allocator_traits::max_size
2285	make_reverse_iterator
2286	stringbuf::underflow() underspecified
2287	[fund.ts] Incorrect exception safety for optional copy assignment operator
2288	Inconsistent requirements for shared mutexes
2289	constexpr guarantees of defaulted functions still insufficient
2290	Top-level "SFINAE"-based constraints should get a separate definition in Clause 17
2291	std::hash is vulnerable to collision DoS attack
2292	Find a better phrasing for "shall not participate in overload resolution"
2293	Wrong facet used by num_put::do_put
2294	<cstdlib> should declare abs(double)
2295	Locale name when the provided Facet is a nullptr
2296	std::addressof should be constexpr
2297	[CD] Missing type requirements for std::exchange
2298	[CD] is_nothrow_constructible is always false because of create<>
2299	[CD] Effects of inaccessible key_compare::is_transparent type are not clear
2300	[CD] Redundant sections for map and multimap members should be removed
2301	Why is std::tie not constexpr?
2302	Passing null pointer to placement new
2303	Explicit instantiation of std::vector<UserType> broken?
2304	Complexity of count in unordered associative containers
2305	[fund.ts] optional forwarding construction/assignment
2306	match_results::reference should be value_type&, not const value_type&
2307	Should the Standard Library use explicit only when necessary?
2308	Clarify container destructor requirements w.r.t. std::array
2309	mutex::lock() should not throw device_or_resource_busy
2310	Public exposition only member in std::array
2311	Allocator requirements should be further minimized
2312	tuple's constructor constraints need to be phrased more precisely
2313	tuple_size should always derive from integral_constant<size_t, N>
2314	apply() should return decltype(auto) and use decay_t before tuple_size
2315	weak_ptr should be movable
2316	weak_ptr::lock() should be atomic
2317	The type property queries should be UnaryTypeTraits returning size_t
2318	basic_string's wording has confusing relics from the copy-on-write era
2319	basic_string's move constructor should not be noexcept
2320	select_on_container_copy_construction() takes allocators, not containers
2321	Moving containers should (usually) be required to preserve iterators
2322	Associative(initializer_list, stuff) constructors are underspecified
2323	vector::resize(n, t)'s specification should be simplified
2324	Insert iterator constructors should use addressof()
2325	minmax_element()'s behavior differing from max_element()'s should be noted
2326	uniform_int_distribution<unsigned char> should be permitted
2327	Non-power-of-two URNGs should be forbidden
2328	Rvalue stream extraction should use perfect forwarding
2329	regex_match()/regex_search() with match_results should forbid temporary strings
2330	regex("meow", regex::icase) is technically forbidden but should be permitted
2331	regex_constants::collate's effects are inaccurately summarized
2332	regex_iterator/regex_token_iterator should forbid temporary regexes
2333	[fund.ts] Hashing disengaged optional<T> objects
2334	atomic's default constructor requires "uninitialized" state even for types with non-trivial default-constructor
2335	array<array<int, 3>, 4> should be layout-compatible with int[4][3]
2336	is_trivially_constructible/is_trivially_assignable traits are always false
2337	shared_ptr operator*() should not be noexcept
2338	§[re.traits]/7 expects of locale facets something not guaranteed by [locale.facet]/4
2339	Wording issue in nth_element
2340	Replacement allocation functions declared as inline
2341	Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)
2342	User conversion to wchar_t const* or to wchar_t not invoked for operator<<
2343	Is the value of the ECMA-262 RegExp object's multiline property really false?
2344	quoted()'s interaction with padding is unclear
2345	integer_sequence should have a self-typedef ::type
2346	integral_constant's member functions should be marked noexcept
2347	reverse_iterator::operator[] calls const version of current[]
2348	charT('1') is not the wide equivalent of '1'
2349	Clarify input/output function rethrow behavior
2350	min, max, and minmax should be constexpr
2351	Does .seed() completely reset state of engine?
2352	Is a default-constructed std::seed_seq intended to produce a predictable .generate()?
2353	std::next is over-constrained
2354	Unnecessary copying when inserting into maps with braced-init syntax
2355	"s" UDL suffix should be reserved for a compile-time string library type
2356	Stability of erasure in unordered associative containers
2357	Remaining "Assignable" requirement
2358	Apparently-bogus definition of is_empty type trait
2359	How does regex_constants::nosubs affect basic_regex::mark_count()?
2360	reverse_iterator::operator*() is unimplementable
2361	Apply 2299 resolution throughout library
2362	unique, associative emplace() should not move/copy the mapped_type constructor arguments when no insertion happens
2363	Defect in 30.4.1.4.1 [thread.sharedtimedmutex.class]
2364	deque and vector pop_back don't specify iterator invalidation requirements
2365	Missing noexcept in shared_ptr::shared_ptr(nullptr_t)
2366	istreambuf_iterator end-of-stream equality
2367	pair and tuple are not correctly implemented for is_constructible with no args
2368	Replacing global operator new
2369	constexpr max(initializer_list) vs max_element
2370	Operations involving type-erased allocators should not be noexcept in std::function
2371	[fund.ts] No template aliases defined for new type traits
2372	Assignment from int to std::string
2373	Make new entities and names in namespace std conforming extensions
2374	[fund.ts] Remarks for optional::to_value are too restrictive
2375	Is [iterator.requirements.general]/9 too broadly applied?
2376	bad_weak_ptr::what() overspecified
2377	std::align requirements overly strict
2378	Behaviour of standard exception types
2379	Obtaining native handle of the current thread
2380	May <cstdlib> provide long ::abs(long) and long long ::abs(long long)?
2381	Inconsistency in parsing floating point numbers
2382	Unclear order of container update versus object destruction on removing an object
2383	Overflow cannot be ill-formed for chrono::duration integer literals
2384	Allocator's deallocate function needs better specification
2385	function::assign allocator argument doesn't make sense
2386	function::operator= handles allocators incorrectly
2387	More nested types that must be accessible and unambiguous
2388	Handling self-assignment in the proposed library function std::exchange
2389	[fund.ts] function::operator= is over-specified and handles allocators incorrectly
2390	[fund.ts] Invocation types and rvalues
2391	basic_string is missing non-const data()
2392	"character type" is used but not defined
2393	std::function's Callable definition is broken
2394	locale::name specification unclear — what is implementation-defined?
2395	[fund.ts] Preconditions: is defined nowhere
2396	underlying_type doesn't say what to do for an incomplete enumeration type
2397	map<K, V>::emplace and explicit V constructors
2398	type_info's destructor shouldn't be required to be virtual
2399	shared_ptr's constructor from unique_ptr should be constrained
2400	shared_ptr's get_deleter() should use addressof()
2401	std::function needs more noexcept
2402	basic_string(const basic_string& str, size_type pos, size_type n = npos) shouldn't use Allocator()
2403	stof() should call strtof() and wcstof()
2404	mismatch()'s complexity needs to be updated
2405	rotate()'s return value is incorrect when middle == first
2406	negative_binomial_distribution should reject p == 1
2407	packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit
2408	SFINAE-friendly common_type/iterator_traits is missing in C++14
2409	[fund.ts] SFINAE-friendly common_type/iterator_traits should be removed from the fundamental-ts
2410	[fund.ts] shared_ptr<array>'s constructor from unique_ptr should be constrained
2411	shared_ptr is only contextually convertible to bool
2412	promise::set_value() and promise::get_future() should not race
2413	assert macro is overconstrained
2414	Member function reentrancy should be implementation-defined
2415	Inconsistency between unique_ptr and shared_ptr
2416	[fund.ts] std::experimental::any allocator support is unimplementable
2417	[fund.ts.v2] std::experimental::optional::operator< and LessThanComparable requirement
2418	[fund.ts] apply does not work with member pointers
2419	Clang's libc++ extension to std::tuple
2420	function<void(ArgTypes...)> does not discard the return value of the target object
2421	Non-specification of handling zero size in std::align [ptr.align]
2422	std::numeric_limits<T>::is_modulo description: "most machines" errata
2423	Missing specification slice_array, gslice_array, mask_array, indirect_array copy constructor
2424	29.5 should state that atomic types are not trivially copyable
2425	operator delete(void*, size_t) doesn't invalidate pointers sufficiently
2426	Issue about compare_exchange
2427	Container adaptors as sequence containers, redux
2428	"External declaration" used without being defined
2429	std::basic_ostringstream is missing an allocator-extended constructor
2430	Heterogeneous container lookup should be enabled using meta-function instead of nested type
2431	Missing regular expression traits requirements
2432	initializer_list assignability
2433	uninitialized_copy()/etc. should tolerate overloaded operator&
2434	shared_ptr::use_count() is efficient
2435	reference_wrapper::operator()'s Remark should be deleted
2436	Comparators for associative containers should always be CopyConstructible
2437	iterator_traits<OutIt>::reference can and can't be void
2438	std::iterator inheritance shouldn't be mandated
2439	unique_copy() sometimes can't fall back to reading its output
2440	seed_seq::size() should be noexcept
2441	Exact-width atomic typedefs should be provided
2442	call_once() shouldn't DECAY_COPY()
2443	std::array member functions should be constexpr
2444	Inconsistent complexity for std::sort_heap
2445	"Stronger" memory ordering
2446	Unspecialized std::tuple_size should be defined
2447	Allocators and volatile-qualified value types
2448	Non-normative Container destructor specification
2449	vector::insert invalidates end()?
2450	(greater|less|greater_equal|less_equal)<void> do not yield a total order for pointers
2451	[fund.ts.v2] optional<T> should 'forward' T's implicit conversions
2452	is_constructible, etc. and default arguments
2453	§[iterator.range] and now [iterator.container] aren't available via <initializer_list>
2454	Add raw_storage_iterator::base() member
2455	Allocator default construction should be allowed to throw
2456	Incorrect exception specifications for 'swap' throughout library
2457	std::begin() and std::end() do not support multi-dimensional arrays correctly
2458	N3778 and new library deallocation signatures
2459	std::polar should require a non-negative rho
2460	LWG issue 2408 and value categories
2461	Interaction between allocators and container exception safety guarantees
2462	std::ios_base::failure is overspecified
2463	[fund.ts] Incorrect complexity for sample() algorithm
2464	try_emplace and insert_or_assign misspecified
2465	SFINAE-friendly common_type is nearly impossible to specialize correctly and regresses key functionality
2466	allocator_traits::max_size() default behavior is incorrect
2467	is_always_equal has slightly inconsistent default
2468	Self-move-assignment of library types
2469	Wrong specification of Requires clause of operator[] for map and unordered_map
2470	Allocator's destroy function should be allowed to fail to instantiate
2471	copy_n's number of InputIterator increments unspecified
2472	Heterogeneous comparisons in the standard library can result in ambiguities
2473	basic_filebuf's relation to C FILE semantics
2474	<cmath> functions unfriendly to integral_constant arguments
2475	Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs
2476	scoped_allocator_adaptor is not assignable
2477	Inconsistency of wordings in std::vector::erase() and std::deque::erase()
2478	Unclear how wstring_convert uses cvtstate
2479	Unclear how wbuffer_convert uses cvtstate
2480	Error handling of wbuffer_convert unclear
2481	wstring_convert should be more precise regarding "byte-error string" etc.
2482	§[c.strings] Table 73 mentions nonexistent functions
2483	throw_with_nested() should use is_final
2484	rethrow_if_nested() is doubly unimplementable
2485	get() should be overloaded for const tuple&&
2486	mem_fn() should be required to use perfect forwarding
2487	bind() should be const-overloaded, not cv-overloaded
2488	Placeholders should be allowed and encouraged to be constexpr
2489	mem_fn() should be noexcept
2490	<regex> needs lots of noexcept
2491	std::less<T*> in constant expression
2492	Clarify requirements for comp
2493	initializer_list supports incomplete classes
2494	[fund.ts.v2] ostream_joiner needs noexcept
2495	There is no such thing as an Exception Safety element
2496	Certain hard-to-avoid errors not in the immediate context are not allowed to be triggered by the evaluation of type traits
2497	Use of uncaught_exception()
2498	operator>>(basic_istream&&, T&&) returns basic_istream&, but should probably return basic_istream&&
2499	operator>>(basic_istream&, CharT*) makes it hard to avoid buffer overflows
2500	[fund.ts.v2] fundts.memory.smartptr.shared.obs/6 should apply to cv-unqualified void
2501	std::function requires POCMA/POCCA
2502	std::function does not use allocator::construct
2503	multiline option should be added to syntax_option_type
2504	basic_streambuf is not an abstract class
2505	auto_ptr_ref creation requirements underspecified
2506	Underspecification of atomics
2507	codecvt_mode should be a bitmask type
2508	§[new.delete.dataraces] wording needs to be updated
2509	[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target
2510	Tag types should not be DefaultConstructible
2511	scoped_allocator_adaptor piecewise construction does not require CopyConstructible
2512	Y2K bites; what is an "unambiguous year identifier"?
2513	Missing requirements for basic_string::value_type
2514	Type traits must not be final
2515	[fund.ts.v2] Certain comparison operators of observer_ptr do not match synopsis
2516	[fund.ts.v2] Public "exposition only" members in observer_ptr
2517	[fund.ts.v2] Two propagate_const assignment operators have incorrect return type
2518	[fund.ts.v2] Non-member swap for propagate_const should call member swap
2519	Iterator operator-= has gratuitous undefined behaviour
2520	N4089 broke initializing unique_ptr<T[]> from a nullptr
2521	[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support
2522	[fund.ts.v2] Contradiction in set_default_resource specification
2523	std::promise synopsis shows two set_value_at_thread_exit()'s for no apparent reason
2524	generate_canonical can occasionally return 1.0
2525	[fund.ts.v2] get_memory_resource should be const and noexcept
2526	[fund.ts.v2] Incorrect precondition for experimental::function::swap
2527	[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default
2528	Order of std::tuple construction unspecified
2529	Assigning to enable_shared_from_this::__weak_this twice
2530	Clarify observable side effects of releasing a shared state
2531	future::get should explicitly state that the shared state is released
2532	Satisfying a promise at thread exit
2533	[concurr.ts] Constrain threads where future::then can run a continuation
2534	Constrain rvalue stream operators
2535	Inconsistency between ostream::write and ostream::operator<<
2536	What should <complex.h> do?
2537	Constructors for priority_queue taking allocators should call make_heap
2538	[parallel.ts] Requirements on data race behavior of iterators and swap should be clarified
2539	[fund.ts.v2] invocation_trait definition definition doesn't work for surrogate call functions
2540	unordered_multimap::insert hint iterator
2541	[parallel.ts] Headers for ExecutionPolicy algorithm overloads
2542	Missing const requirements for associative containers
2543	LWG 2148 (hash support for enum types) seems under-specified
2544	istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0
2545	Simplify wording for bind without explicitly specified return type
2546	Implementability of locale-sensitive UnicodeEscapeSequence matching
2547	Container requirements (and other library text) should say "strict total order", not just "total order"
2548	Missing vfscanf from <cstdio>
2549	Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references
2550	Wording of unordered container's clear() method complexity
2551	[fund.ts.v2] "Exception safety" cleanup in library fundamentals required
2552	priority_queue doesn't work with move-only types
2553	[fund.ts.v2] basic_string_view substring constructor
2554	Swapping multidimensional arrays is never noexcept
2555	[fund.ts.v2] No handling for over-aligned types in optional
2556	Wide contract for future::share()
2557	Logical operator traits are broken in the zero-argument case
2558	[fund.ts.v2] Logical operator traits are broken in the zero-argument case
2559	Error in LWG 2234's resolution
2560	is_constructible underspecified when applied to a function type
2561	[fund.ts.v2] Incorrect exception specifications for 'swap' in C++ Extensions for Library Fundamentals
2562	Consistent total ordering of pointers by comparison functors
2563	LWG 2259 relaxes requirements, perhaps unintentionally
2564	[fund.ts.v2] std::experimental::function constructors taking allocator arguments may throw exceptions
2565	std::function's move constructor should guarantee nothrow for reference_wrappers and function pointers
2566	Requirements on the first template parameter of container adaptors
2567	Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
2568	[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
2569	conjunction and disjunction requirements are too strict
2570	[fund.ts.v2] conjunction and disjunction requirements are too strict
2571	§[map.modifiers]/2 imposes nonsensical requirement on insert(InputIterator, InputIterator)
2572	The remarks for shared_ptr::operator* should apply to cv-qualified void as well
2573	[fund.ts.v2] std::hash<std::experimental::shared_ptr<T>> does not work for arrays
2574	[fund.ts.v2] std::experimental::function::operator=(F&&) should be constrained
2575	[fund.ts.v2] experimental::function::assign should be removed
2576	istream_iterator and ostream_iterator should use std::addressof
2577	{shared,unique}_lock should use std::addressof
2578	Iterator requirements should reference iterator traits
2579	Inconsistency wrt Allocators in basic_string assignment vs. basic_string::assign
2580	Who is definitive: operator= or assign?
2581	Specialization of <type_traits> variable templates should be prohibited
2582	§[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits
2583	There is no way to supply an allocator for basic_string(str, pos)
2584	<regex> ECMAScript IdentityEscape is ambiguous
2585	forward_list::resize(size_type, const value_type&) effects incorrect
2586	Wrong value category used in scoped_allocator_adaptor::construct()
2587	"Convertible to bool" requirement in conjunction and disjunction
2588	[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction
2589	match_results can't satisfy the requirements of a container
2590	Aggregate initialization for std::array
2591	std::function's member template target() should not lead to undefined behaviour
2592	Require that chrono::duration_casts from smaller durations to larger durations do not overflow
2593	Moved-from state of Allocators
2594	Contradicting definition of empty shared_ptr on shared_ptr(nullptr, d)
2595	reverse_iterator::operator[]'s return type revisited
2596	vector::data() should use addressof
2597	std::log misspecified for complex numbers
2598	addressof works on temporaries
2599	Library incomplete type permission phrase is unclear
2600	ios_base must store inaccessible iostate flags
2601	[filesys.ts] [PDTS] Make namespaces consistent with Library TS policy
2602	[filesys.ts] [PDTS] Tighten specification when there is no reasonable behavior
2603	[filesys.ts] [PDTS] Filename length needs bullet item
2604	[filesys.ts] [PDTS] Need definition of dot and dot-dot
2605	[filesys.ts] [PDTS] Parent of root directory unspecified
2606	[filesys.ts] [PDTS] Path depth is underspecified
2607	[filesys.ts] [PDTS] Unhelpful comment for struct space_info
2608	[filesys.ts] [PDTS] file_time_type underspecified
2609	[filesys.ts] [PDTS] Unclear why range-based-for functions return different types
2610	[filesys.ts] [PDTS] Apparently inconsistent return types from several functions
2611	[filesys.ts] [PDTS] Lack of relative() operation function
2612	[filesys.ts] [PDTS] uintmax_t too small for large file sizes
2613	[filesys.ts] [PDTS] Missing actual error conditions thrown
2614	[filesys.ts] [PDTS] Incorrect postconditions for path copy/move constructor
2615	[filesys.ts] [PDTS] Missing behavior for characters with no representation
2616	[filesys.ts] [PDTS] Append behavior underspecified if target is empty
2617	[filesys.ts] [PDTS] path member swap() unnecessary
2618	[filesys.ts] [PDTS] is_absolute() return clause confusing
2619	[filesys.ts] [PDTS] Consider using quoted manipulators
2621	[filesys.ts] [PDTS] directory_entry operator== needs clarification
2622	[filesys.ts] [PDTS] directory_iterator underspecified
2623	[filesys.ts] [PDTS] Request for create_regular_file() and/or touch()
2624	[filesys.ts] [PDTS] Incorrect effects clause for path copy
2625	[filesys.ts] [PDTS] Copying equivalent paths effects not specified
2626	[filesys.ts] [PDTS] Equivalence is a volatile property
2627	[filesys.ts] [PDTS] Return value of uintmax_t on error?
2628	[filesys.ts] [PDTS] Possible last_write_time() postcondition?
2629	[filesys.ts] [PDTS] Unclear semantics of read_symlink on error
2630	[filesys.ts] [PDTS] remove() must avoid race
2631	[filesys.ts] [PDTS] POSIX guarantees atomicity for rename()
2632	[filesys.ts] [PDTS] system_complete() example needs clarification
2633	[filesys.ts] [PDTS] unique_path() is a security vulnerability
2634	[filesys.ts] [PDTS] enum class directory_options has no summary
2635	[filesys.ts] [PDTS] directory_options::skip_permission_denied is not used
2636	[filesys.ts] [PDTS] copy_options::copy_symlinks is not used
2637	[filesys.ts] [PDTS] All functions with error_code arguments should be noexcept
2638	[filesys.ts] [PDTS] Make certain functions noexcept and drop error_code version
2639	[filesys.ts] [PDTS] permissions() is missing from synopsis
2640	[filesys.ts] [PDTS] class directory_entry should retain operator const path&() from V2
2641	[filesys.ts] [PDTS] directory_iterator, recursive_directory_iterator, move construct/assign should be noexcept
2642	[filesys.ts] [PDTS] class path should have defaulted constructors/destructor/assignments.
2643	[filesys.ts] [PDTS] path::compare(const string&) should be path::compare(const string_type&)
2644	[filesys.ts] [PDTS] enum classes copy_options and perms should be bitmask types
2645	[filesys.ts] [PDTS] create_directory should refer to perms::all instead of Posix S_IRWXU|S_IRWXG|S_IRWXO
2646	[filesys.ts] [PDTS] Do we really need generic*?
2647	[filesys.ts] [PDTS] last_write_time() uses ill-formed cast
2648	[filesys.ts] [PDTS] path::template<class charT>string() conversion rules
2649	[filesys.ts] [PDTS] path and directory_entry move ctors should not be noexcept
2650	[filesys.ts] [PDTS] path::compare(const string& s) wrong argument type
2651	[filesys.ts] [PDTS] directory_iterator, recursive_directory_iterator, pointer/reference typedefs wrong
2652	[filesys.ts] [PDTS] Better to avoid deriving from std::iterator
2653	[filesys.ts] [PDTS] directory_entry multithreading concerns
2654	[filesys.ts] [PDTS] Concerns with security and testability
2655	[filesys.ts] [PDTS] Clarify Error reporting
2656	[filesys.ts] [PDTS] Feature test macro for TS version
2657	[filesys.ts] [PDTS] Inappropriate use of "No diagnostic is required"
2658	[filesys.ts] [PDTS] POSIX utime() is obsolescent
2659	[filesys.ts] [PDTS] Invalid expressions for bitmask types
2660	[filesys.ts] [PDTS] Incorrect Throws specification for absolute()
2661	[filesys.ts] Surprising equivalent() behavior if neither file exists
2662	[filesys.ts] Allocator requirements unspecified
2663	Enable efficient retrieval of file size from directory_entry
2664	operator/ (and other append) semantics not useful if argument has root
2665	remove_filename() post condition is incorrect
2666	Bitmask operations should use bitmask terms
2667	path::root_directory() description is confusing
2668	path::operator+= is defined, but not operator+
2669	recursive_directory_iterator effects refers to non-existent functions
2670	system_complete refers to undefined variable 'base'
2671	Errors in Copy
2672	Should is_empty use error_code in its specification?
2673	status() effects cannot be implemented as specified
2674	Bidirectional iterator requirement on path::iterator is very expensive
2675	register_callback can fail
2676	Provide filesystem::path overloads for File-based streams
2677	directory_entry::status is not allowed to be cached as a quality-of-implementation issue
2678	std::filesystem enum classes overspecified
2679	Inconsistent Use of Effects and Equivalent To
2680	Add "Equivalent to" to filesystem
2681	filesystem::copy() cannot copy symlinks
2682	filesystem::copy() won't create a symlink to a directory
2683	filesystem::copy() says "no effects"
2684	priority_queue lacking comparator typedef
2685	shared_ptr deleters must not not throw on move construction
2686	Why is std::hash specialized for error_code, but not error_condition?
2687	{inclusive,exclusive}_scan misspecified
2688	clamp misses preconditions and has extraneous condition on result
2689	Parallel versions of std::copy and std::move shouldn't be in order
2690	invoke<R>
2691	money_base::space and do_put: U+0020 versus fill
2692	Overspecification of lvalueness of bitmask elements
2693	constexpr for various std::complex arithmetic and value operators
2694	Application of LWG 436 accidentally deleted definition of "facet"
2695	"As if" unclear in [member.functions]
2696	Interaction between make_shared and enable_shared_from_this is underspecified
2697	[concurr.ts] Behavior of future/shared_future unwrapping constructor when given an invalid future
2698	Effect of assign() on iterators/pointers/references
2699	Missing restriction in [numeric.requirements]
2700	resource_adaptor went missing
2701	Unclear requirement in [memory.resource.private]
2702	num_put::do_put(..., bool) performs ill-formed do_put call
2703	No provision for fill-padding when boolalpha is set
2704	recursive_directory_iterator's members should require '*this is dereferenceable'
2705	Questionable precondition on Sequence containers a.assign(n, t)
2706	Error reporting for recursive_directory_iterator::pop() is under-specified
2707	path construction and assignment should have "string_type&&" overloads
2708	recursive_directory_iterator::recursion_pending() is incorrectly specified
2709	offsetof is unnecessarily imprecise
2710	"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics
2711	path is convertible from approximately everything under the sun
2712	copy_file(from, to, ...) has a number of unspecified error conditions
2713	More missing allocator-extended constructors for unordered containers
2714	complex stream extraction underspecified
2715	What is 'aggregate initialization syntax'?
2716	Specification of shuffle and sample disallows lvalue URNGs
2717	scoped_allocator_adaptor uses forward to do move's job
2718	Parallelism bug in [algorithms.parallel.exec] p2
2719	permissions function should not be noexcept due to narrow contract
2720	permissions function incorrectly specified for symlinks
2721	remove_all has incorrect post conditions
2722	equivalent incorrectly specifies throws clause
2723	Do directory_iterator and recursive_directory_iterator become the end iterator upon error?
2724	The protected virtual member functions of memory_resource should be private
2725	filesystem::exists(const path&, error_code&) error reporting
2726	[recursive_]directory_iterator::increment(error_code&) is underspecified
2727	Parallel algorithms with constexpr specifier
2728	status(p).permissions() and symlink_status(p).permissions() are not specified
2729	Missing SFINAE on std::pair::operator=
2730	numeric_limits primary template definition
2731	Existence of lock_guard<MutexTypes...>::mutex_type typedef unclear
2732	Questionable specification of path::operator/= and path::append
2733	[fund.ts.v2] gcd / lcm and bool
2734	Questionable specification in [fs.path.concat]
2735	std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C
2736	nullopt_t insufficiently constrained
2737	Consider relaxing object size restrictions for single-object allocation functions
2738	is_constructible with void types
2739	Issue with time_point non-member subtraction with an unsigned duration
2740	constexpr optional<T>::operator->
2741	is_partitioned requirements need updating
2742	Inconsistent string interface taking string_view
2743	p0083r3 node_handle private members missing "exposition only" comment
2744	any's in_place constructors
2745	[fund.ts.v2] Implementability of LWG 2451
2746	Inconsistency between requirements for emplace between optional and variant
2747	Possibly redundant std::move in [alg.foreach]
2748	swappable traits for optionals
2749	swappable traits for variants
2750	[fund.ts.v2] LWG 2451 conversion constructor constraint
2751	shared_ptr deleter not specified to observe expired weak_ptr instances
2752	"Throws:" clauses of async and packaged_task are unimplementable
2753	Optional's constructors and assignments need constraints
2754	The in_place constructors and emplace functions added by P0032R3 don't require CopyConstructible
2755	§[string.view.io] uses non-existent basic_string_view::to_string function
2756	C++ WP optional<T> should 'forward' T's implicit conversions
2757	std::string{}.insert(3, "ABCDE", 0, 1) is ambiguous
2758	std::string{}.assign("ABCDE", 0, 1) is ambiguous
2759	gcd / lcm and bool for the WP
2760	non-const basic_string::data should not invalidate iterators
2761	directory_entry comparisons are members
2762	unique_ptr operator*() should be noexcept
2763	common_type_t<void, void> is undefined
2764	Are <cstddint> macros optional?
2765	Did LWG 1123 go too far?
2766	Swapping non-swappable types
2767	not_fn call_wrapper can form invalid types
2768	any_cast and move semantics
2769	Redundant const in the return type of any_cast(const any&)
2770	tuple_size<const T> specialization is not SFINAE compatible and breaks decomposition declarations
2771	Broken Effects of some basic_string::compare functions in terms of basic_string_view
2772	Inconsistency in the insert(node) interface
2773	Making std::ignore constexpr
2774	std::function construction vs assignment
2775	reverse_iterator is does not compile for fancy pointers
2776	shared_ptr unique() and use_count()
2777	basic_string_view::copy should use char_traits::copy
2778	basic_string_view is missing constexpr
2779	[networking.ts] Relax requirements on buffer sequence iterators
2780	basic_string_view::copy is missing constexpr
2781	Contradictory requirements for std::function and std::reference_wrapper
2782	scoped_allocator_adaptor constructors must be constrained
2783	stack::emplace() and queue::emplace() should return decltype(auto)
2784	Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse
2785	quoted should work with basic_string_view
2786	Annex C should mention shared_ptr changes for array support
2787	§[fs.file_status.cons] doesn't match class definition
2788	basic_string range mutators unintentionally require a default constructible allocator
2789	Equivalence of contained objects
2790	Missing specification of istreambuf_iterator::operator->
2791	string_view objects and strings should yield the same hash values
2792	[fund.ts.v2] gcd and lcm should support a wider range of input values
2793	Awkward conflation of trivial special members of istream_iterator
2794	Missing requirements for allocator pointers
2795	§[global.functions] provides incorrect example of ADL use
2796	tuple should be a literal type
2797	Trait precondition violations
2798	Definition of path in terms of a string
2799	noexcept-specifications in shared_future
2800	constexpr swap
2801	Default-constructibility of unique_ptr
2802	shared_ptr constructor requirements for a deleter
2803	hash for arithmetic, pointer and standard library types should not throw
2804	Unconditional constexpr default constructor for istream_iterator
2805	void and reference type alternatives in variant, variant<> and index()
2806	Base class of bad_optional_access
2807	std::invoke should use std::is_nothrow_callable
2808	Requirements for fpos and stateT
2809	variant hash requirements
2810	use_count and unique in shared_ptr
2811	"Selected constructor" wording is incorrect for optional/variant/any
2812	Range access is available with <string_view>
2813	std::function should not return dangling references
2814	[fund.ts.v2] to_array should take rvalue reference as well
2815	quick_exit can deadlock
2816	resize_file has impossible postcondition
2817	std::hash for nullptr_t
2818	"::std::" everywhere rule needs tweaking
2819	Unspecified Return type: elements
2820	Clarify <cstdint> macros
2821	std::launder() should be marked as [[nodiscard]]
2822	Resolution for LWG 2742 introduces ambiguities
2823	std::array initialization is still not permissive enough
2824	list::sort should say that the order of elements is unspecified if an exception is thrown
2825	LWG 2756 breaks class template argument deduction for optional
2826	string_view iterators use old wording
2827	is_trivially_constructible and non-trivial destructors
2828	Clarify <cstdalign> (following adoption of P0063r3)
2829	LWG 2740 leaves behind vacuous words
2830	insert_return_type is only defined for containers with unique keys
2831	Equality can be defined when Hash function objects have different behaviour
2832	§[fpos.operations] strange requirement for P(i)
2833	Library needs to specify what it means when it declares a function constexpr
2834	Resolution LWG 2223 is missing wording about end iterators
2835	LWG 2536 seems to misspecify <tgmath.h>
2836	More string operations should be noexcept
2837	gcd and lcm should support a wider range of input values
2838	is_literal_type specification needs a little cleanup
2839	Self-move-assignment of library types, again
2840	directory_iterator::increment is seemingly narrow-contract but marked noexcept
2841	Use of "Equivalent to" in [strings]
2842	in_place_t check for optional::optional(U&&) should decay U
2843	Unclear behavior of std::pmr::memory_resource::do_allocate()
2844	Stability of a_uniq.insert(i, j)
2845	enable_if, result_of, common_type and aligned_storage do not meet the definition of TransformationTrait
2846	Undefined phrase "effectively cast"
2847	sin(float) should call sinf(float)
2848	Pass-through threshold for pool allocator
2849	Why does !is_regular_file(from) cause copy_file to report a "file already exists" error?
2850	std::function move constructor does unnecessary work
2851	std::filesystem enum classes are now underspecified
2852	Specifications of operator== for std::basic_strings and std::basic_string_views are difficult to conform to
2853	Possible inconsistency in specification of erase in [vector.modifiers]
2854	wstring_convert provides no indication of incomplete input or output
2855	std::throw_with_nested("string_literal")
2856	std::async should be marked as [[nodiscard]]
2857	{variant,optional,any}::emplace should return the constructed value
2858	LWG 2472: actually an incompatibility with C++03
2859	Definition of reachable in [ptr.launder] misses pointer arithmetic from pointer-interconvertible object
2860	launder and base class subobjects
2861	basic_string should require that charT match traits::char_type
2862	LWG 2756 should be accepted
2863	Undo default_order changes of maps and sets
2864	Merge shared_ptr changes from Library Fundamentals to C++17
2865	Resolve all open Library issues for C++17
2866	Incorrect derived classes constraints
2867	Bad footnote about explicit exception-specification
2868	Missing specification of bad_any_cast::what()
2869	Deprecate sub-clause [locale.stdcvt]
2870	Default value of parameter theta of polar should be dependent
2871	User specializations of type traits should be ill-formed
2872	Add definition for direct-non-list-initialization
2873	Add noexcept to several shared_ptr related functions
2874	Constructor shared_ptr::shared_ptr(Y*) should be constrained
2875	shared_ptr::shared_ptr(Y*, D, […]) constructors should be constrained
2876	shared_ptr::shared_ptr(const weak_ptr<Y>&) constructor should be constrained
2877	Strengthen meaning of "empty shared_ptr<T>" in dynamic_pointer_cast
2878	Missing DefaultConstructible requirement for istream_iterator default constructor
2879	Removing C dependencies from signal handler wording
2880	Relax complexity specifications for non-sequenced policies
2881	Adopt section III of P0308R0
2882	Clarify variant construction
2883	The standard library should provide string_view parameters instead or in addition for functions defined with char const * or string const & as parameter types.
2884	Relational operators for containers should sfinae; if the underlying type is not comparable, neither should the container be
2885	The relational operators of optional and variant completely reflect the semantics of the element types — this is inconsistent with other types in the library
2886	Keep the empty() functions in any
2887	Revert the changes from P0156R0: variadic lock_guard
2888	Variables of library tag types need to be inline variables
2889	Mark constexpr global variables as inline
2890	The definition of 'object state' applies only to class types
2891	Relax library requirements on volatile types
2892	Relax the prohibition on libraries adding constexpr
2893	Parsing Hexadecimally in P0067R4
2894	The function template std::apply() is required to be constexpr, but std::invoke() isn't
2895	Passing function types to result_of and is_callable
2896	The contents of <codecvt> are underspecified
2897	array::iterator and array::const_iterator should be literal types
2898	Prefer not to use member typedefs as constructor parameters
2899	is_(nothrow_)move_constructible and tuple, optional and unique_ptr
2900	The copy and move constructors of optional are not constexpr
2901	Variants cannot properly support allocators
2902	variant should only support complete types
2903	The form of initialization for the emplace-constructors is not specified
2904	Make variant move-assignment more exception safe
2905	is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible
2906	There is no ability to supply an allocator for the control block when constructing a shared_ptr from a unique_ptr
2907	Semantics for destroying the deleter and the control-block of a shared_ptr are unclear
2908	The less-than operator for shared pointers could do more
2909	User specializations of is_execution_policy should be ill-formed
2910	Template deduction and integral_constant
2911	An is_aggregate type trait is needed
2912	Add a deduction guide for class template duration
2913	Containers need deduction guides
2914	std::array does not support class-template deduction from initializers
2915	The three container adapters should each have a deduction guide
2916	Insert iterators should each have an instantiation guide to initialize from a container
2917	Parallel algorithms cannot easily work with InputIterators
2918	Possible need for extra storage in inner_product
2919	The specification for adjacent_difference has baked-in sequential semantics
2920	Add a deduction guide for creating a shared_future from a future rvalue
2921	packaged_task and type-erased allocators
2922	The *_constant<> templates do not make use of template<auto>
2923	noexcept is inconsistently applied across headers which import components of the C standard library
2924	An ExecutionPolicy overload for inner_product() seems impractical
2925	Template argument deduction is not used in the standard library
2926	INVOKE(f, t1, t2,... tN) and INVOKE(f, t1, t2,... tN, R) are too similar
2927	Encoding a functor and argument types as a function signature for is_callable and result_of is fragile
2928	is_callable is not a good name
2929	basic_string misuses "Effects: Equivalent to"
2930	Are implementations allowed to split non-member functions into several overloads?
2931	Missed optimization opportunity with single-argument std::next
2932	Constraints on parallel algorithm implementations are underspecified
2933	PR for LWG 2773 could be clearer
2934	optional<const T> doesn't compare with T
2935	What should create_directories do when p already exists but is not a directory?
2936	Path comparison is defined in terms of the generic format
2937	Is equivalent("existing_thing", "not_existing_thing") an error?
2938	basic_string_view::const_iterator should be literal types
2939	Some type-completeness constraints of traits are overspecified
2940	result_of specification also needs a little cleanup
2941	§[thread.req.timing] wording should apply to both member and namespace-level functions
2942	LWG 2873's resolution missed weak_ptr::owner_before
2943	Problematic specification of the wide version of basic_filebuf::open
2944	LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception
2945	Order of template parameters in optional comparisons
2946	LWG 2758's resolution missed further corrections
2947	Clarify several filesystem terms
2948	unique_ptr does not define operator<< for stream output
2949	Unclear complexity requirements: space vs. time
2950	std::byte operations are misspecified
2951	iterator_traits should SFINAE for void* and function pointers
2952	iterator_traits should work for pointers to cv T
2953	LWG 2853 should apply to deque::erase too
2954	Specialization of the convenience variable templates should be prohibited
2955	to_chars / from_chars depend on std::string
2956	filesystem::canonical() still defined in terms of absolute(p, base)
2957	bind's specification doesn't apply the cv-qualification of the call wrapper to the callable object
2958	Moves improperly defined as deleted
2959	char_traits<char16_t>::eof is a valid UTF-16 code unit
2960	[fund.ts.v3] nonesuch is insufficiently useless
2961	Bad postcondition for set_default_resource
2962	Iterators of Containers of move-only types do not model InputIterator
2963	Algorithms with underspecified iterator requirements
2964	Apparently redundant requirement for dynamic_pointer_cast
2965	Non-existing path::native_string() in filesystem_error::what() specification
2966	Incomplete resolution of US 74
2967	std::equal on empty ranges
2968	Inconsistencies between basic_string reserve and vector/unordered_map/unordered_set reserve functions
2969	polymorphic_allocator::construct() shouldn't pass resource()
2970	Return type of std::visit misspecified
2971	variant should require Destructible types
2972	What is is_trivially_destructible_v<int>?
2973	inplace_merge exact comparison count complexity prohibits useful real-world optimizations
2974	Diagnose out of bounds tuple_element/variant_alternative
2975	Missing case for pair construction in scoped and polymorphic allocators
2976	Dangling uses_allocator specialization for packaged_task
2977	unordered_meow::merge() has incorrect Throws: clause
2978	Hash support for pmr::string and friends
2979	aligned_union should require complete object types
2980	Cannot compare_exchange empty pointers
2981	Remove redundant deduction guides from standard library
2982	Making size_type consistent in associative container deduction guides
2983	money_put::do_put underspecified
2984	put_money(99) is unnecessarily undefined
2985	std::reverse should be permitted to be vectorized
2986	Handling of multi-character collating elements by the regex FSM is underspecified
2987	Relationship between traits_inst.lookup_collatename and the regex FSM is underspecified with regards to ClassAtomCollatingElement
2988	Clause 32 cleanup missed one typename
2989	path's stream insertion operator lets you insert everything under the sun
2990	optional::value_type is not always a value type
2991	variant copy constructor missing noexcept(see below)
2992	system_category() and error_code::error_code() should be constexpr
2993	reference_wrapper<T> conversion from T&&
2994	Needless UB for basic_string and basic_string_view
2995	basic_stringbuf default constructor forbids it from using SSO capacity
2996	Missing rvalue overloads for shared_ptr operations
2997	LWG 491 and the specification of {forward_,}list::unique
2998	Requirements on function objects passed to {forward_,}list-specific algorithms
2999	§[thread.decaycopy] issue
3000	monotonic_memory_resource::do_is_equal uses dynamic_cast unnecessarily
3001	weak_ptr::element_type needs remove_extent_t
3002	[networking.ts] basic_socket_acceptor::is_open() isn't noexcept
3003	<future> still has type-erased allocators in promise
3004	§[string.capacity] and §[vector.capacity] should specify time complexity for capacity()
3005	Destruction order of arrays by make_shared/allocate_shared only recommended?
3006	Constructing a basic_stringbuf from a string — where does the allocator come from?
3007	allocate_shared should rebind allocator to cv-unqualified value_type for construction
3008	make_shared (sub)object destruction semantics are not specified
3009	Including <string_view> doesn't provide std::size/empty/data
3010	[networking.ts] uses_executor says "if a type T::executor_type exists"
3011	Requirements for assert(E) inconsistent with C
3012	atomic<T> is unimplementable for non-is_trivially_copy_constructible T
3013	(recursive_)directory_iterator construction and traversal should not be noexcept
3014	More noexcept issues with filesystem operations
3015	copy_options::unspecified underspecified
3016	optional and over-aligned types
3017	list splice functions should use addressof
3018	shared_ptr of function type
3019	Presentation of "program defined classes derived from error_category" [syserr.errcat.derived] unclear and contains mistakes
3020	[networking.ts] Remove spurious nested value_type buffer sequence requirement
3021	[networking.ts] Relax pointer equivalence requirement for ConstBufferSequence
3022	is_convertible<derived*, base*> may lead to ODR
3023	Clarify unspecified call wrappers
3024	variant's copies must be deleted instead of disabled via SFINAE
3025	Map-like container deduction guides should use pair<Key, T>, not pair<const Key, T>
3026	filesystem::weakly_canonical still defined in terms of canonical(p, base)
3027	[networking.ts] DynamicBuffer prepare exception specification
3028	Container requirements tables should distinguish const and non-const variables
3029	pop_heap over-constrains input
3030	Who shall meet the requirements of try_lock?
3031	Algorithms and predicates with non-const reference arguments
3032	ValueSwappable requirement missing for push_heap and make_heap
3033	basic_string move ctor is underspecified
3034	P0767R1 breaks previously-standard-layout types
3035	std::allocator's constructors should be constexpr
3036	polymorphic_allocator::destroy is extraneous
3037	polymorphic_allocator and incomplete types
3038	polymorphic_allocator::allocate should not allow integer overflow to create vulnerabilities
3039	Unnecessary decay in thread and packaged_task
3040	basic_string_view::starts_with Effects are incorrect
3041	Unnecessary decay in reference_wrapper
3042	is_literal_type_v should be inline
3043	Bogus postcondition for filesystem_error constructor
3044	Strange specification of max_size() for an allocator
3045	atomic<floating-point> doesn't have value_type or difference_type
3046	Do not require reference_wrapper to support non-referenceable function types
3047	atomic compound assignment operators can cause undefined behavior when corresponding fetch_meow members don't
3048	transform_reduce(exec, first1, last1, first2, init) discards execution policy
3049	Missing wording allowing algorithms to use copies of function objects as substitutes for their parameters
3050	Conversion specification problem in chrono::duration constructor
3051	Floating point classifications were inadvertently changed in P0175
3052	visit is underconstrained
3053	Prohibit error_code construction from rvalues of error_category
3054	uninitialized_copy appears to not be able to meet its exception-safety guarantee
3055	path::operator+=(single-character) misspecified
3056	copy_file() copies which attributes?
3057	Correct copy_options handling
3058	Parallel adjacent_difference shouldn't require creating temporaries
3059	Wrong requirements for map-like associative container assignment?
3060	XXX_scan algorithms are specified to work with move-only T, but are specified to make N copies of T into the destination range
3061	What is the return type of compare_3way?
3062	Unnecessary decay_t in is_execution_policy_v should be remove_cvref_t
3063	Parallel algorithms in <memory> are underspecified
3064	How do uninitialized memory algorithms obtain pointer without undefined behavior?
3065	LWG 2989 missed that all path's other operators should be hidden friends as well
3066	"report a domain error" in [sf.cmath]/1 is underspecified
3067	recursive_directory_iterator::pop must invalidate
3068	Forbid assigning an rvalue basic_string to basic_string_view
3069	Move assigning variant's subobject corrupts data
3070	path::lexically_relative causes surprising results if a filename can also be a root-name
3071	[networking.ts] read_until still refers to "input sequence"
3072	[networking.ts] DynamicBuffer object lifetimes underspecified
3073	[networking.ts] (async_)read and (async_)write don't support DynamicBuffer lvalues
3074	Non-member functions for valarray should only deduce from the valarray
3075	basic_string needs deduction guides from basic_string_view
3076	basic_string CTAD ambiguity
3077	(push|emplace)_back should invalidate the end iterator
3078	directory_entry, directory_iterator and recursive_directory_iterator perform needless path copies
3079	LWG 2935 forgot to fix the existing_p overloads of create_directory
3080	Floating point from_chars pattern specification breaks round-tripping
3081	Floating point from_chars API does not distinguish between overflow and underflow
3082	from_chars specification regarding floating point rounding is inconsistent
3083	What should ios::iword(-1) do?
3084	Termination in C++ is unclear
3085	char_traits::copy precondition too weak
3086	Possible problem in §[new.delete.single]
3087	One final &x in §[list.ops]
3088	forward_list::merge behavior unclear when passed *this
3089	copy_n should require non-overlapping ranges
3090	What is §[time.duration.cons]p4's "no overflow is induced in the conversion" intended to mean?
3091	subsecond-precision time_of_day and durations that seconds cannot convert to
3092	Unclear semantics of enum class bitmask types
3093	LWG 2294/2192 missed a std::abs overload
3094	§[time.duration.io]p4 makes surprising claims about encoding
3095	strstreambuf refers to nonexistent member of fpos, fpos::offset
3096	path::lexically_relative is confused by trailing slashes
3097	basic_stringbuf seekoff effects trigger undefined behavior and have contradictory returns
3098	Misleading example for filesystem::path::filename()
3099	is_assignable<Incomplete&, Incomplete&>
3100	Unnecessary and confusing "empty span" wording
3101	span's Container constructors need another constraint
3102	Clarify span iterator and const_iterator behavior
3103	Errors in taking subview of span should be ill-formed where possible
3104	Fixing duration division
3105	T1 is convertible to T2
3106	nothrow should be inline constexpr rather that extern const
3107	istreambuf_iterator has public exposition-only member
3108	istreambuf_iterator::proxy::operator* should be const
3109	strstreambuf is copyable
3110	Contiguous Iterators should always be Random-Access
3111	Too strong precondition on basic_string constructor
3112	system_error and filesystem_error constructors taking a string may not be able to meet their postconditions
3113	polymorphic_allocator::construct() should more closely match scoped_allocator_adaptor::construct()
3114	[networking.ts] Permit efficient composition when using DynamicBuffer
3115	Unclear description for algorithm includes
3116	OUTERMOST_ALLOC_TRAITS needs remove_reference_t
3117	Missing packaged_task deduction guides
3118	fpos equality comparison unspecified
3119	Program-definedness of closure types
3120	Unclear behavior of monotonic_buffer_resource::release()
3121	tuple constructor constraints for UTypes&&... overloads
3122	__cpp_lib_chrono_udls was accidentally dropped
3123	duration constructor from representation shouldn't be effectively non-throwing
3124	[networking.ts] Unclear how execution_context is intended to store services
3125	duration streaming precondition should be a SFINAE condition
3126	There's no std::sub_match::compare(string_view) overload
3127	basic_osyncstream::rdbuf needs a const_cast
3128	strstream::rdbuf needs a const_cast
3129	regex_token_iterator constructor uses wrong pointer arithmetic
3130	§[input.output] needs many addressof
3131	addressof all the things
3132	Library needs to ban macros named expects or ensures
3133	Modernizing numeric type requirements
3134	[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961
3135	[fund.ts.v3] LFTSv3 contains two redundant alias templates
3136	[fund.ts.v3] LFTSv3 awkward wording in propagate_const requirements
3137	Header for __cpp_lib_to_chars
3138	There is no such thing as assertion-level
3139	contract_violation's special member functions
3140	COMMON_REF is unimplementable as specified
3141	CopyConstructible doesn't preserve source values
3142	std::foo<incomplete> should be ill-formed NDR
3143	monotonic_buffer_resource growth policy is unclear
3144	span does not have a const_pointer typedef
3145	file_clock breaks ABI for C++17 implementations
3146	Excessive unwrapping in std::ref/cref
3147	Definitions of "likely" and "unlikely" are likely to cause problems
3148	<concepts> should be freestanding
3149	DefaultConstructible should require default initialization
3150	UniformRandomBitGenerator should validate min and max
3151	ConvertibleTo rejects conversions from array and function types
3152	common_type and common_reference have flaws in common
3153	Common and common_type have too little in common
3154	Common and CommonReference have a common defect
3155	tuple<any, any>{allocator_arg_t, an_allocator}
3156	ForwardIterator should only mean forward iterator
3157	Allocator destroy and fancy pointer operations must be non-throwing
3158	tuple(allocator_arg_t, const Alloc&) should be conditionally explicit
3159	§[unique.ptr.single] requirements on deleter may be too strict
3160	atomic_ref() = delete; should be deleted
3161	Container adapters mandate use of emplace_back but don't require it
3162	system_error::system_error(error_code ec) not explicit
3163	[networking.ts] Buffer sequence iterator equivalency
3164	Unhelpful "shall not participate" constraints for unique_ptr with reference deleter
3165	All starts_with() overloads should be called "begins_with"
3166	No such descriptive element as Value:
3167	[fund.ts.v3] Does observer_ptr support function types?
3168	Expects: element should be specified in one place
3169	ranges permutation generators discard useful information
3170	is_always_equal added to std::allocator makes the standard library treat derived types as always equal
3171	LWG 2989 breaks directory_entry stream insertion
3172	3-arg std::hypot is underspecified compared to the 2-arg overload
3173	Enable CTAD for ref-view
3174	Precondition on is_convertible is too strong
3175	The CommonReference requirement of concept SwappableWith is not satisfied in the example
3176	Underspecified behavior of unordered containers when Container::key_equal differs from Pred
3177	Limit permission to specialize variable templates to program-defined types
3178	std::mismatch is missing an upper bound
3179	subrange should always model Range
3180	Inconsistently named return type for ranges::minmax_element
3181	split_view::outer_iterator converting constructor is misconstrained
3182	Specification of Same could be clearer
3183	Normative permission to specialize Ranges variable templates
3184	Inconsistencies in bind_front wording
3185	Uses-allocator construction functions missing constexpr and noexcept
3186	ranges removal, partition, and partial_sort_copy algorithms discard useful information
3187	P0591R4 reverted DR 2586 fixes to scoped_allocator_adaptor::construct()
3188	istreambuf_iterator::pointer should not be unspecified
3189	Missing requirement for std::priority_queue
3190	std::allocator::allocate sometimes returns too little storage
3191	std::ranges::shuffle synopsis does not match algorithm definition
3192	§[allocator.uses.construction] functions misbehave for const types
3193	Mandates: and Expects: elements are not defined for types
3194	ConvertibleTo prose does not match code
3195	What is the stored pointer value of an empty weak_ptr?
3196	std::optional<T> is ill-formed is T is an array
3197	std::prev should not require BidirectionalIterator
3198	Bad constraint on std::span::span()
3199	istream >> bitset<0> fails
3200	midpoint should not constrain T is complete
3201	lerp should be marked as noexcept
3202	P0318R1 was supposed to be revised
3203	span element access invalidation
3204	sub_match::swap only swaps the base class
3205	decay_t in the new common_type fallback should be remove_cvref_t
3206	year_month_day conversion to sys_days uses not-existing member function
3207	N in ssize(const T (&)[N]) should be size_t
3208	Boolean's expression requirements are ordered inconsistently
3209	Expression in year::ok() returns clause is ill-formed
3210	allocate_shared is inconsistent about removing const from the pointer passed to allocator construct and destroy
3211	std::tuple<> should be trivially constructible
3212	tuple_element_t<1, const span<int, 42>> is const int
3213	for_each_n and copy_n missing requirements for Size
3214	§[facet.num.get.virtuals] doesn't say what it means for digit grouping to be consistent
3215	variant default constructor has vague constexpr requirements
3216	Rebinding the allocator before calling construct/destroy in allocate_shared
3217	<memory> and <execution> should define __cpp_lib_parallel_algorithm
3218	Modifier for %d parse flag does not match POSIX and format specification
3219	std::array overview container requirements are incorrect
3220	P0558 broke conforming C++14 uses of atomic shared_ptr
3221	Result of year_month arithmetic with months is ambiguous
3222	P0574R1 introduced preconditions on non-existent parameters
3223	lerp should not add the "sufficient additional overloads"
3224	zoned_time constructor from TimeZonePtr does not specify initialization of tp_
3225	zoned_time converting constructor shall not be noexcept
3226	zoned_time constructor from string_view should accept zoned_time<Duration2, TimeZonePtr2>
3227	Ambiguity issue for extract in ordered and unordered associative containers
3228	Surprising variant construction
3229	§[res.on.exception.handling]#3 cannot apply to types with implicitly declared destructors
3230	Format specifier %y/%Y is missing locale alternative versions
3231	year_month_day_last::day specification does not cover !ok() values
3232	Inconsistency in zoned_time deduction guides
3233	Broken requirements for shared_ptr converting constructors
3234	Sufficient Additional Special Math Overloads
3235	parse manipulator without abbreviation is not callable
3236	Random access iterator requirements lack limiting relational operators domain to comparing those from the same range
3237	LWG 3038 and 3190 have inconsistent PRs
3238	Insufficiently-defined behavior of std::function deduction guides
3239	Hidden friends should be specified more narrowly
3240	Headers declare more than entities
3241	chrono-spec grammar ambiguity in §[time.format]
3242	std::format: missing rules for arg-id in width and precision
3243	std::format and negative zeroes
3244	Constraints for Source in §[fs.path.req] insufficiently constrainty
3245	Unnecessary restriction on '%p' parse specifier
3246	What are the constraints on the template parameter of basic_format_arg?
3247	ranges::iter_move should perform ADL-only lookup of iter_move
3248	std::format #b, #B, #o, #x, and #X presentation types misformat negative numbers
3249	There are no 'pointers' in §[atomics.lockfree]
3250	std::format: # (alternate form) for NaN and inf
3251	Are std::format alignment specifiers applied to string arguments?
3252	Parse locale's aware modifiers for commands are not consistent with POSIX spec
3253	basic_syncbuf::basic_syncbuf() should not be explicit
3254	Strike stop_token's operator!=
3255	span's array constructor is too strict
3256	Feature testing macro for constexpr algorithms
3257	Missing feature testing macro update from P0858
3258	Range access and initializer_list
3259	The definition of constexpr iterators should be adjusted
3260	year_month* arithmetic rejects durations convertible to years
3261	regex components' noexcept annotations appear broken for POCMA or throwing BidirectionalIterator
3262	Formatting of negative durations is not specified
3263	Atomic waiting function calls should only be unblocked once
3264	sized_range and ranges::size redundantly use disable_sized_range
3265	move_iterator's conversions are more broken after P1207
3266	to_chars(bool) should be deleted
3267	Rebound allocators and is_always_equal
3268	memory_order::memory_order_foo broken in C++20
3269	Parse manipulators do not specify the result of the extraction from stream
3270	Parsing and formatting %j with durations
3271	Parsing functions should save and restore stream format state
3272	%I%p should parse/format duration since midnight
3273	Specify weekday_indexed to range of [0, 7]
3274	Missing feature test macro for <span>
3275	Why does time_get::do_get require a valid pointer when none of the others do?
3276	Class split_view::outer_iterator::value_type should inherit from view_interface
3277	Pre-increment on prvalues is not a requirement of weakly_incrementable
3278	join_view<V>::iterator<true> tries to write through const join_view ptr
3279	shared_ptr<int>& does not not satisfy readable
3280	View converting constructors can cause constraint recursion and are unneeded
3281	Conversion from pair-like types to subrange is a silent semantic promotion
3282	subrange converting constructor should disallow derived to base conversions
3283	Types satisfying input_iterator but not equality_comparable look like C++17 output iterators
3284	random_access_iterator semantic constraints accidentally promote difference type using unary negate
3285	The type of a customization point object shall satisfy semiregular
3286	ranges::size is not required to be valid after a call to ranges::begin on an input range
3287	Exposition-only cpp17-input-iterator concept is needlessly complex
3288	atomic<T>::notify_one is unimplementable
3289	Cannot opt out of C++17 iterator-ness without also opting out of C++20 iterator-ness
3290	Are std::format field widths code units, code points, or something else?
3291	iota_view::iterator has the wrong iterator_category
3292	iota_view is under-constrained
3293	move_iterator operator+() has incorrect constraints
3294	zoned_time deduction guides misinterprets string/char*
3295	Comparison category operator== are mis-specified
3296	Inconsistent default argument for basic_regex<>::assign
3297	Useless sequence container requirement
3298	Range adaptors introduced by P1035 do not require viewable_range
3299	Pointers don't need customized iterator behavior
3300	Non-array ssize overload is underconstrained
3301	transform_view::iterator has incorrect iterator_category
3302	Range adaptor objects keys and values are unspecified
3303	Bad "constexpr" marker for destroy/destroy_n
3304	Allocate functions of std::polymorphic_allocator should require [[nodiscard]]
3305	any_cast<void>
3306	ranges::advance violates its preconditions
3307	std::allocator<void>().allocate(n)
3308	vector and deque iterator erase invalidates elements even when no change occurs
3309	Is <ios> implicitly #included by <sstream>, <fstream> etc.?
3310	Replace SIZE_MAX with numeric_limits<size_t>::max()
3311	basic_string::operator=(charT c) should be constrained
3312	polymorphic_allocator::allocate_object and new_object should be [[nodiscard]]
3313	join_view::iterator::operator-- is incorrectly constrained
3314	Is stream insertion behavior locale dependent when Period::type is micro?
3315	Correct Allocator Default Behavior
3316	Correctly define epoch for utc_clock / utc_timepoint
3317	Incorrect operator<< for floating-point durations
3318	Clarify whether clocks can represent time before their epoch
3319	Properly reference specification of IANA time zone database
3320	span::cbegin/cend methods produce different results than std::[ranges::]cbegin/cend
3321	uninitialized_construct_using_allocator should use construct_at
3322	Add join_view::base() member function
3323	has-tuple-element helper concept needs convertible_to
3324	Special-case std::strong/weak/partial_order for pointers
3325	Constrain return type of transformation function for transform_view
3326	enable_view has false positives
3327	Format alignment specifiers vs. text direction
3328	Clarify that std::string is not good for UTF-8
3329	totally_ordered_with both directly and indirectly requires common_reference_with
3330	Include <compare> from most library headers
3331	Define totally_ordered/_with in terms of partially-ordered-with
3332	Issue in §[time.format]
3333	ranges::cbegin/ranges::cend, (and maybe ranges::crbegin/ranges::crend) are under-specified to allow rvalue-arrays
3334	basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
3335	Resolve C++20 NB comments US 273 and GB 274
3336	How does std::vformat handle exception thrown by formatters?
3337	What is "is initialized" supposed to mean?
3338	Rename default_constructible to default_initializable
3339	Move-constructed empty-container capacity
3340	Formatting functions should throw on argument/format string mismatch in §[format.functions]
3341	basic_regex range constructor: Missing requirements for iterator types
3342	Library wording uses "initializes x with y", which is underspecified
3343	Ordering of calls to unlock() and notify_all() in Effects element of notify_all_at_thread_exit() should be reversed
3344	advance(i, most-negative) and prev(i, most-negative)
3345	Incorrect usages of "models" versus "satisfies"
3346	pair and tuple copy and move constructor have backwards specification
3347	std::pair<T, U> now requires T and U to be less-than-comparable
3348	__cpp_lib_unwrap_ref in wrong header
3349	Missing __cpp_lib_constexpr_complex for P0415R1
3350	Simplify return type of lexicographical_compare_three_way
3351	ranges::enable_safe_range should not be constrained
3352	strong_equality isn't a thing
3353	locale's copy assignment operator should return locale&
3354	has_strong_structural_equality has a meaningless definition
3355	The memory algorithms should support move-only input iterators introduced by P1207
3356	__cpp_lib_nothrow_convertible should be __cpp_lib_is_nothrow_convertible
3357	[fund.ts.v3] default_random_engine is overspecified for per-thread engine
3358	§[span.cons] is mistaken that to_address can throw
3359	<chrono> leap second support should allow for negative leap seconds
3360	three_way_comparable_with is inconsistent with similar concepts
3361	safe_range<SomeRange&> case
3362	Strike stop_source's operator!=
3363	drop_while_view should opt-out of sized_range
3364	Initialize data members of ranges and their iterators
3365	Rename ref-is-glvalue to deref-is-ref
3366	Narrowing conversions between integer and integer-class types
3367	Integer-class conversions should not throw
3368	Exactly when does size return end - begin?
3369	span's deduction-guide for built-in arrays doesn't work
3370	§[cstdint.syn]p2 and §[headers]p5 are not sufficiently clear
3371	visit_format_arg and make_format_args are not hidden friends
3372	vformat_to should not try to deduce Out twice
3373	{to,from}_chars_result and format_to_n_result need the "we really mean what we say" wording
3374	P0653 + P1006 should have made the other std::to_address overload constexpr
3375	decay in viewable_range should be remove_cvref
3376	"integer-like class type" is too restrictive
3377	elements_view::iterator befriends a specialization of itself
3378	tuple_size_v/tuple_element_t should be available when tuple_size/tuple_element are
3379	"safe" in several library names is misleading
3380	common_type and comparison categories
3381	begin and data must agree for contiguous_range
3382	NTTP for pair and array
3383	§[time.zone.leap.nonmembers] sys_seconds should be replaced with seconds
3384	transform_view::sentinel has an incorrect operator-
3385	common_iterator is not sufficiently constrained for non-copyable iterators
3386	elements_view needs its own sentinel type
3387	§[range.reverse.view] reverse_view<V> unintentionally requires range<const V>
3388	view iterator types have ill-formed <=> operators
3389	A move-only iterator still does not have a counted_iterator
3390	make_move_iterator() cannot be used to construct a move_iterator for a move-only iterator
3391	Problems with counted_iterator/move_iterator::base() const &
3392	ranges::distance() cannot be used on a move-only iterator with a sized sentinel
3393	Missing/incorrect feature test macro for coroutines
3394	ranges::basic_istream_view::iterator has an empty iterator_traits
3395	Definition for three-way comparison needs to be updated (US 152)
3396	Clarify point of reference for source_location::current() (DE 169)
3397	ranges::basic_istream_view::iterator should not provide iterator_category
3398	tuple_element_t is also wrong for const subrange
3399	basic_syncbuf::emit() + Qt's #define emit = Big Bada-Boom
3400	Does is_nothrow_convertible consider destruction of the destination type?
3401	Is "as if by" equivalent to "equivalent to"?
3402	Wording for negative_binomial_distribution is unclear as a consequence of LWG 2406 resolution
3403	Domain of ranges::ssize(E) doesn't match ranges::size(E)
3404	Finish removing subrange's conversions from pair-like
3405	common_view's converting constructor is bad, too
3406	elements_view::begin() and elements_view::end() have incompatible constraints
3407	Some problems with the wording changes of P1739R4
3408	LWG 3291 reveals deficiencies in counted_iterator
3409	Too lax description of atomic_ref<T>::required_alignment
3410	lexicographical_compare_three_way is overspecified
3411	[fund.ts.v3] Contradictory namespace rules in the Library Fundamentals TS
3412	§[format.string.std] references to "Unicode encoding" unclear
3413	[fund.ts.v3] propagate_const's swap's noexcept specification needs to be constrained and use a trait
3414	[networking.ts] service_already_exists has no usable constructors
3415	back_insert_iterator fails when a container is also its value type
3416	The Throws: specification of std::any does not mention allocation
3417	Missing volatile atomic deprecations
3418	Deprecated free functions in <atomic>
3419	§[algorithms.requirements]/15 doesn't reserve as many rights as it intends to
3420	cpp17-iterator should check that the type looks like an iterator first
3421	Imperfect ADL emulation for boolean-testable
3422	Issues of seed_seq's constructors
3423	std::any_cast should never return a cv-qualified type
3424	optional::value_or should never return a cv-qualified type
3425	condition_variable_any fails to constrain its Lock parameters
3426	operator<=>(const unique_ptr<T, D>&, nullptr_t) can't get no satisfaction
3427	operator<=>(const shared_ptr<T>&, nullptr_t) definition ill-formed
3428	single_view's in place constructor should be explicit
3429	"models" should subsume like "satisfies"
3430	std::fstream & co. should be constructible from string_view
3431	<=> for containers should require three_way_comparable<T> instead of <=>
3432	Missing requirement for comparison_category
3433	subrange::advance(n) has UB when n < 0
3434	ios_base never reclaims memory for iarray and parray
3435	three_way_comparable_with<reverse_iterator<int*>, reverse_iterator<const int*>>
3436	std::construct_at should support arrays
3437	__cpp_lib_polymorphic_allocator is in the wrong header
3438	§[container.node.overview] missing multiset/map cases
3439	"Distance" template parameter is underspecified
3440	Aggregate-paren-init breaks direct-initializing a tuple or optional from {aggregate-member-value}
3441	Misleading note about calls to customization points
3442	Unsatisfiable suggested implementation of customization points
3443	[networking.ts] net::basic_socket_iostream should use addressof
3444	[networking.ts] net::basic_socket_streambuf::connect(Args&&...) effects are wrong
3445	[networking.ts] net::basic_socket_istream::connect should be constrained
3446	indirectly_readable_traits ambiguity for types with both value_type and element_type
3447	Deduction guides for take_view and drop_view have different constraints
3448	transform_view's sentinel<false> not comparable with iterator<true>
3449	take_view and take_while_view's sentinel<false> not comparable with their const iterator
3450	The const overloads of take_while_view::begin/end are underconstrained
3451	Inconsistently explicit deduction guides
3452	Are views really supposed to have strict 𝒪(1) destruction?
3453	Generic code cannot call ranges::advance(i, s)
3454	pointer_traits::pointer_to should be constexpr
3455	Incorrect Postconditions on unique_ptr move assignment
3456	Pattern used by std::from_chars is underspecified
3457	*this is not invalidated
3458	Is shared_future intended to work with arrays or function types?
3459	Why doesn't std::convertible_to have semantic requirement when To is reference-to-function type?
3460	Unimplementable noop_coroutine_handle guarantees
3461	convertible_to's description mishandles cv-qualified void
3462	§[formatter.requirements]: Formatter requirements forbid use of fc.arg()
3463	Incorrect requirements for transform_inclusive_scan without initial value
3464	istream::gcount() can overflow
3465	compare_partial_order_fallback requires F < E
3466	Specify the requirements for promise/future/shared_future consistently
3467	bool can't be an integer-like type
3468	Transparent lookups in unordered containers are inconsistent
3469	Precondition of coroutine_handle::promise may be insufficient
3470	convertible-to-non-slicing seems to reject valid case
3471	polymorphic_allocator::allocate does not satisfy Cpp17Allocator requirements
3472	counted_iterator is missing preconditions
3473	Normative encouragement in non-normative note
3474	Nesting join_views is broken because of CTAD
3475	std::thread's constructor needs to be able to report general memory allocation failures
3476	thread and jthread constructors require that the parameters be move-constructible but never move construct the parameters
3477	Simplify constraints for semiregular-box
3478	views::split drops trailing empty range
3479	semiregular-box mishandles self-assignment
3480	directory_iterator and recursive_directory_iterator are not C++20 ranges
3481	viewable_range mishandles lvalue move-only views
3482	drop_view's const begin should additionally require sized_range
3483	transform_view::iterator's difference is overconstrained
3484	Should <stddef.h> declare ::nullptr_t?
3485	atomic_ref safety should be based on operations that "potentially conflict" rather than lifetime
3486	is_constructible<T[], T...> may be misleading in C++20
3487	Missing precondition on input and output aliasing of [numeric.ops]
3488	Is array<const int, 0> swappable or not?
3489	Improve istream_view wording
3490	ranges::drop_while_view::begin() is missing a precondition
3491	What is a "decayed type"?
3492	Minimal improvements to elements_view::iterator
3493	The constructor of std::function taking an F is missing a constraint
3494	Allow ranges to be conditionally borrowed
3495	constexpr launder makes pointers to inactive members of unions usable
3496	What does "uniquely associated" mean for basic_syncbuf::emit()?
3497	Postconditions for basic_syncbuf::emit()
3498	Inconsistent noexcept-specifiers for basic_syncbuf
3499	Timed lockable and mutex requirements are imprecise about duration and time_point
3500	join_view::iterator::operator->() is bogus
3501	basic_syncbuf-related manipulators refer to some Allocator without defining it
3502	elements_view should not be allowed to return dangling references
3503	chrono::ceil has surprising requirement
3504	condition_variable::wait_for is overspecified
3505	split_view::outer-iterator::operator++ misspecified
3506	Missing allocator-extended constructors for priority_queue
3507	P0881R7 ("stacktrace") does not define "actual file name", "actual line number"
3508	atomic_ref<cv T> is not well-specified
3509	Range adaptor objects are underspecified
3510	Customization point objects should be invocable as non-const too
3511	Clarify global permission to move
3512	Incorrect exception safety guarantee for unordered containers
3513	Fix definition of program-defined based on its uses
3514	stacktrace should add type alias pmr::stacktrace
3515	§[stacktrace.basic.nonmem]: operator<< should be less templatized
3516	thread::id spaceship may be inconsistent with equality
3517	join_view::iterator's iter_swap is underconstrained
3518	Exception requirements on char trait operations unclear
3519	Incomplete synopses for <random> classes
3520	iter_move and iter_swap are inconsistent for transform_view::iterator
3521	Overly strict requirements on qsort and bsearch
3522	Missing requirement on InputIterator template parameter for priority_queue constructors
3523	iota_view::sentinel is not always iota_view's sentinel
3524	Unimplementable narrowing and evaluation order requirements for range adaptors
3525	uses_allocator_construction_args fails to handle types convertible to pair
3526	Return types of uses_allocator_construction_args unspecified
3527	uses_allocator_construction_args handles rvalue pairs of rvalue references incorrectly
3528	make_from_tuple can perform (the equivalent of) a C-style cast
3529	priority_queue(first, last) should construct c with (first, last)
3530	BUILTIN-PTR-MEOW should not opt the type out of syntactic checks
3531	LWG 3025 broke previous valid code
3532	split_view<V, P>::inner-iterator<true>::operator++(int) should depend on Base
3533	Make base() const & consistent across iterator wrappers that supports input_iterators
3534	ranges::set_intersection and ranges::set_difference algorithm requirements are too strict
3535	join_view::iterator::iterator_category and ::iterator_concept lie
3536	Should chrono::from_stream() assign zero to duration for failure?
3537	§[iterator.range] Missing noexcept for std::rbegin/rend for arrays and initializer_list
3538	§[library.c] C library functions are not addressable
3539	format_to must not copy models of output_iterator<const charT&>
3540	§[format.arg] There should be no const in basic_format_arg(const T* p)
3541	indirectly_readable_traits should be SFINAE-friendly for all types
3542	basic_format_arg mis-handles basic_string_view with custom traits
3543	Definition of when counted_iterators refer to the same sequence isn't quite right
3544	format-arg-store::args is unintentionally not exposition-only
3545	std::pointer_traits should be SFINAE-friendly
3546	common_iterator's postfix-proxy is not quite right
3547	Time formatters should not be locale sensitive by default
3548	shared_ptr construction from unique_ptr should move (not copy) the deleter
3549	view_interface is overspecified to derive from view_base
3550	Names reserved by C for standard library not reserved by C++
3551	borrowed_{iterator,subrange}_t are overspecified
3552	Parallel specialized memory algorithms should require forward iterators
3553	Useless constraint in split_view::outer-iterator::value_type::begin()
3554	chrono::parse needs const charT* and basic_string_view<charT> overloads
3555	{transform,elements}_view::iterator::iterator_concept should consider const-qualification of the underlying range
3556	Specification of when semantic constraints are imposed by use of concepts is unclear
3557	The static_cast expression in convertible_to has the wrong operand
3558	elements_view::sentinel's first operator- has wrong return type
3559	Semantic requirements of sized_range is circular
3560	ranges::equal and ranges::is_permutation should short-circuit for sized_ranges
3561	Issue with internal counter in discard_block_engine
3562	Superseding nullopt_t's requirement to not be DefaultConstructible
3563	keys_view example is broken
3564	transform_view::iterator<true>::value_type and iterator_category should use const F&
3565	Handling of encodings in localized formatting of chrono types is underspecified
3566	Constraint recursion for operator<=>(optional<T>, U)
3567	Formatting move-only iterators take two
3568	basic_istream_view needs to initialize value_
3569	join_view fails to support ranges of ranges with non-default_initializable iterators
3570	basic_osyncstream::emit should be an unformatted output function
3571	flush_emit should set badbit if the emit call fails
3572	copyable-box should be fully constexpr
3573	Missing Throws element for basic_string_view(It begin, End end)
3574	common_iterator should be completely constexpr-able
3575	<=> for integer-class types isn't consistently specified
3576	Clarifying fill character in std::format
3577	Merging an (unordered) associative container with itself
3578	Iterator SCARYness in the context of associative container merging
3579	Complexity guarantees for resize() and append() functions across the library
3580	iota_view's iterator's binary operator+ should be improved
3581	The range constructor makes basic_string_view not trivially move constructible
3582	Unclear where std::async exceptions are handled
3583	Clarify if/when short circuiting applies to conditions in Constraints: elements
3584	Clarify common comparison category conversions
3585	Variant converting assignment with immovable alternative
3586	Formatting character alignment inconsistencies
3587	std::three_way_comparable_with<T, U, void> can be satisfied but can't be modeled
3588	Strike out purposeless UB involving the deleter in members functions of unique_ptr
3589	The const lvalue reference overload of get for subrange does not constrain I to be copyable when N == 0
3590	split_view::base() const & is overconstrained
3591	lazy_split_view<input_view>::inner-iterator::base() && invalidates outer iterators
3592	lazy_split_view needs to check the simpleness of Pattern
3593	Several iterators' base() const & and lazy_split_view::outer-iterator::value_type::end() missing noexcept
3594	inout_ptr — inconsistent release() in destructor
3595	Exposition-only classes proxy and postfix-proxy for common_iterator should be fully constexpr
3596	ranges::starts_with and ranges::ends_with are underspecified
3597	Unsigned integer types don't model advanceable
3598	system_category().default_error_condition(0) is underspecified
3599	The const overload of lazy_split_view::begin should be constrained by const Pattern
3600	Making istream_iterator copy constructor trivial is an ABI break
3601	common_iterator's postfix-proxy needs indirectly_readable
3602	reverse_iterator's converting assignment is overconstrained
3603	Matching of null characters by regular expressions is underspecified
3604	What is the effect of an invalid value of type syntax_option_type?
3605	regex_constants::match_prev_avail is underspecified
3606	Missing regex_traits::locale_type requirements
3607	contiguous_iterator should not be allowed to have custom iter_move and iter_swap behavior
3608	convertible_to and temporary-bound references
3609	std::ranges::iota_view<int, long> has non-subtractable iterator and sentinel types
3610	iota_view::size sometimes rejects integer-class types
3611	Should compare_exchange be allowed to modify the expected value on success?
3612	Inconsistent pointer alignment in std::format
3613	Specify that nullopt_t is copyable
3614	iota_view::size and the most negative signed integer values
3615	The last specialization of incrementable_traits has wrong operand types
3616	LWG 3498 seems to miss the non-member swap for basic_syncbuf
3617	function/packaged_task deduction guides and deducing this
3618	Unnecessary iter_move for transform_view::iterator
3619	Specification of vformat_to contains ill-formed formatted_size calls
3620	What are execution character sets and execution wide-character sets (after P2314R4)?
3621	Remove feature-test macro __cpp_lib_monadic_optional
3622	Misspecified transitivity of equivalence in §[unord.req.general]
3623	Uses of std::reverse_iterator with containers should not require manually including <iterator>
3624	Inconsistency of <typeinfo>, <initializer_list>, and <compare> in the standard library
3625	Should <stacktrace> provide range access function templates?
3626	Is std::basic_stacktrace required to use contiguous storage?
3627	Inconsistent specifications for std::make_optional overloads
3628	"Effects: Equivalent to:" and uninitialized memory algorithms
3629	make_error_code and make_error_condition are customization points
3630	Inconsistent basic_regex construction and assignment from iterator range
3631	basic_format_arg(T&&) should use remove_cvref_t<T> throughout
3632	unique_ptr "Mandates: This constructor is not selected by class template argument deduction"
3633	Atomics are copy constructible and copy assignable from volatile atomics
3634	When are static-duration memory_resource objects destroyed?
3635	Add __cpp_lib_deduction_guides to feature test macros
3636	formatter<T>::format should be const-qualified
3637	pmr::memory_resource::do_allocate needs clarification
3638	vector<bool>::swap(reference, reference) is useless
3639	Handling of fill character width is underspecified in std::format
3640	Clarify which exceptions are propagated
3641	Add operator== to format_to_n_result
3642	move_only_function assignment operators seem to be defined suboptimal
3643	Missing constexpr in std::counted_iterator
3644	std::format does not define "integer presentation type"
3645	resize_and_overwrite is overspecified to call its callback with lvalues
3646	std::ranges::view_interface::size returns a signed type
3647	nothrow-input-iterator constraints should not mention copying
3648	format should not print bool with 'c'
3649	[fund.ts.v3] Reinstate and bump __cpp_lib_experimental_memory_resource feature test macro
3650	Are std::basic_string's iterator and const_iterator constexpr iterators?
3651	Unspecified lifetime guarantees for the format string
3652	Can we relax the preconditions of longjmp?
3653	<coroutine> is freestanding, but uses std::hash which is not
3654	basic_format_context::arg(size_t) should be noexcept
3655	The INVOKE operation and union types
3656	Inconsistent bit operations returning a count
3657	std::hash<std::filesystem::path> is not enabled
3658	basic_streambuf::sputn is both overspecified and underspecified
3659	Consider ATOMIC_FLAG_INIT undeprecation
3660	iterator_traits<common_iterator>::pointer should conform to §[iterator.traits]
3661	constinit atomic<shared_ptr<T>> a(nullptr); should work
3662	basic_string::append/assign(NTBS, pos, n) suboptimal
3663	basic_string(const T&, const Alloc&) turns moves into copies
3664	LWG 3392 broke std::ranges::distance(a, a+3)
3665	Is std::allocator_traits<Alloc>::rebind_alloc SFINAE-friendly?
3666	join_view's difference type is too small
3667	std::cout << &X::f prints 1
3668	[recursive_]directory_iterator constructors refer to undefined options
3669	std::filesystem operations should be observable behaviour
3670	Cpp17InputIterators don't have integer-class difference types
3671	atomic_fetch_xor missing from stdatomic.h
3672	common_iterator::operator->() should return by value
3673	§[locale.cons] Ambiguous argument in Throws for locale+name+category constructor
3674	Removal of requirement for locale names for construction of locales not explained
3675	std::ios_base::iword/pword might be misspecified
3676	Name of locale composed using std::locale::none
3677	Is a cv-qualified pair specially handled in uses-allocator construction?
3678	Constructors of std::chrono::time_zone might be overly unspecified
3679	Is <ranges> sufficient for istream_view?
3680	Constructor of move_only_function with empty ref-qualifier is over-constrained
3681	Further considerations on LWG 3679
3682	A Cpp17Allocator type can't silently ignore an unsupported alignment
3683	operator== for polymorphic_allocator cannot deduce template argument in common cases
3684	std::allocator<T>::allocate_at_least in constant evaluation
3685	In lazy_split_view, CTAD doesn't work when given an input_range input and a tiny-range pattern
3686	In lazy_split_view, comparing a default-constructed outer-iterator or inner-iterator with std::default_sentinel results in null pointer dereference
3687	expected<cv void, E> move constructor should move
3688	Exception specifications of copy/move member functions of std::bad_expected_access
3689	num_get overflow determination unclear and incorrect
3690	std::make_from_tuple etc. should find all tuple-like std::get overloads
3691	Replacement of keys in associative containers
3692	zip_view::iterator's operator<=> is overconstrained
3693	§[c.math] Can any of float/double/long double overloads be fused into template overloads?
3694	Should traits_type::length be customizable?
3695	The standard-layout property of char-like types serves for nothing
3696	"Basic integral types" should not be used
3697	Preconditions of reference_constructs_from_temporary/reference_converts_from_temporary seem wrong
3698	regex_iterator and join_view don't work together very well
3699	lexically_relative on UNC drive paths (\\?\C:\...) results in a default-constructed value
3700	The const begin of the join_view family does not require InnerRng to be a range
3701	Make formatter<remove_cvref_t<const charT[N]>, charT> requirement explicit
3702	Should zip_transform_view::iterator remove operator<?
3703	Missing requirements for expected<T, E> requires is_void<T>
3704	LWG 2059 added overloads that might be ill-formed for sets
3705	Hashability shouldn't depend on basic_string's allocator
3706	How does std::format work with character arrays of unknown bound?
3707	chunk_view::outer-iterator::value_type::size should return unsigned type
3708	take_while_view::sentinel's conversion constructor should move
3709	LWG-3703 was underly ambitious
3710	The end of chunk_view for input ranges can be const
3711	Missing preconditions for slide_view constructor
3712	chunk_view and slide_view should not be default_initializable
3713	Sorted with respect to comparator (only)
3714	Non-single-argument constructors for range adaptors should not be explicit
3715	view_interface::empty is overconstrained
3716	§[iterator.concept.forward][forward.iterators] Two different definitions of multi-pass guarantee
3717	common_view::end should improve random_access_range case
3718	P2418R2 broke the overload resolution for std::basic_format_arg
3719	Directory iterators should be usable with default sentinel
3720	Restrict the valid types of arg-id for width and precision in std-format-spec
3721	Allow an arg-id with a value of zero for width in std-format-spec
3722	ranges::to reserves the wrong size
3723	priority_queue::push_range needs to append_range
3724	decay-copy should be constrained
3725	reverse_iterator::operator-> should not use prev for non-pointer iterators
3726	reverse_iterator::operator-> is underconstrained for non-pointer iterators
3727	reverse_iterator/common_iterator's operator-> should not require the underlying iterator's operator-> to be a const member function
3728	Can't make neither head nor tail of the description of operator<=>(tuple, tuple)
3729	std::tuple_element_t<std::ranges::subrange<I, S, K>> should remove top-level cv-qualifiers
3730	std::ranges::drop_view may have different size type from its underlying view
3731	zip_view and adjacent_view are underconstrained
3732	prepend_range and append_range can't be amortized constant time
3733	ranges::to misuses cpp17-input-iterator
3734	Inconsistency in inout_ptr and out_ptr for empty case
3735	views::adjacent<0> should be prohibited
3736	move_iterator missing disable_sized_sentinel_for specialization
3737	take_view::sentinel should provide operator-
3738	Missing preconditions for take_view constructor
3739	chunk_view::size should preserve the signedness of the size of the underlying range
3740	slide_view::size should preserve the signedness of underlying range's size
3741	std::chrono::abs(duration) is ill-formed with non-reduced periods
3742	deque::prepend_range needs to permute
3743	ranges::to's reserve may be ill-formed
3744	copy_symlink(junction, new_symlink)'s behavior is unclear
3745	std::atomic_wait and its friends lack noexcept
3746	optional's spaceship with U with a type derived from optional causes infinite constraint meta-recursion
3747	ranges::uninitialized_copy_n, ranges::uninitialized_move_n, and ranges::destroy_n should use std::move
3748	common_iterator and counted_iterator' operator- are missing cast to return type
3749	common_iterator should handle integer-class difference types
3750	Too many papers bump __cpp_lib_format
3751	Missing feature macro for flat_set
3752	Should string::substr forward the allocator to the newly created string?
3753	Clarify entity vs. freestanding entity
3754	Class template expected synopsis contains declarations that do not match the detailed description
3755	tuple-for-each can call user-defined operator,
3756	Is the std::atomic_flag class signal-safe?
3757	What's the effect of std::forward_like<void>(x)?
3758	Element-relocating operations of std::vector and std::deque should conditionally require Cpp17CopyInsertable in their preconditions
3759	ranges::rotate_copy should use std::move
3760	cartesian_product_view::iterator's parent_ is never valid
3761	cartesian_product_view::iterator::operator- should pass by reference
3762	generator::iterator::operator== should pass by reference
3763	Should range adaptor iterators only provide iterator_category when its difference_type is not an integer-class type?
3764	reference_wrapper::operator() should propagate noexcept
3765	const_sentinel should be constrained
3766	view_interface::cbegin is underconstrained
3767	codecvt<charN_t, char8_t, mbstate_t> incorrectly added to locale
3768	possibly-const-range is overconstrained
3769	basic_const_iterator::operator== causes infinite constraint recursion
3770	const_sentinel_t is missing
3771	[fund.ts.v3] remove binders typedefs from function
3772	repeat_view's piecewise constructor is missing Postconditions
3773	views::zip_transform still requires F to be copy_constructible when empty pack
3774	<flat_set> should include <compare>
3775	Broken dependencies in the Cpp17Allocator requirements
3776	Avoid parsing format-spec if it is not present or empty
3777	Common cartesian_product_view produces an invalid range if the first range is input and one of the ranges is empty
3778	vector<bool> missing exception specifications
3779	ranges::fold_* can unintentionally const_cast and reinterpret_cast
3780	format's width estimation is too approximate and not forward compatible
3781	The exposition-only alias templates cont-key-type and cont-mapped-type should be removed
3782	Should <math.h> declare ::lerp?
3783	views::common may not be a range adaptor object
3784	std.compat should not provide ::byte and its friends
3785	ranges::to is over-constrained on the destination type being a range
3786	Flat maps' deduction guide needs to default Allocator to be useful
3787	ranges::to's template parameter C should not be a reference type
3788	jthread::operator=(jthread&&) postconditions are unimplementable under self-assignment
3789	Precondition of (not replaced) operator delete[]
3790	P1467 accidentally changed nexttoward's signature
3791	join_view::iterator::operator-- may be ill-formed
3792	__cpp_lib_constexpr_algorithms should also be defined in <utility>
3793	Requirements for some algorithms' Size template parameters are unclear
3794	std::filesystem::path::iterator::reference should be allowed to be std::filesystem::path
3795	Self-move-assignment of std::future and std::shared_future have unimplementable postconditions
3796	movable-box as member should use default-initialization instead of copy-initialization
3797	elements_view insufficiently constrained
3798	Rvalue reference and iterator_category
3799	Should <math.h> provide 3-argument ::hypot overloads?
3800	No deduction guide for std::match_results
3801	cartesian_product_view::iterator::distance-from ignores the size of last underlying range
3802	flat_foo allocator-extended constructors lack move semantics
3803	flat_foo constructors taking KeyContainer lack KeyCompare parameter
3804	flat_foo missing some allocator-extended deduction guides
3805	Expression evaluating to a call wrapper is a prvalue, not an object
3806	Should concept formattable<T, charT> default to char?
3807	The feature test macro for ranges::find_last should be renamed
3808	Inconsistent feature test macros for ranges algorithms
3809	Is std::subtract_with_carry_engine<uint16_t> supposed to work?
3810	CTAD for std::basic_format_args
3811	views::as_const on ref_view<T> should return ref_view<const T>
3812	[fund.ts.v3] Incorrect constraint on propagate_const conversion function
3813	std::span<volatile T, E> is made ill-formed by P2278R4 when T is a normal class type
3814	Add freestanding items requested by NB comments
3815	Freestanding enumerators specification is lacking
3816	flat_map and flat_multimap should impose sequence container requirements
3817	Missing preconditions on forward_list modifiers
3818	Exposition-only concepts are not described in library intro
3819	reference_meows_from_temporary should not use is_meowible
3820	cartesian_product_view::iterator::prev is not quite right
3821	uses_allocator_construction_args should have overload for pair-like
3822	Avoiding normalization in filesystem::weakly_canonical
3823	Unnecessary precondition for is_aggregate
3824	Number of bind placeholders is underspecified
3825	Missing compile-time argument id check in basic_format_parse_context::next_arg_id
3826	Redundant specification [for overload of yield_value]
3827	Deprecate <stdalign.h> and <stdbool.h> macros
3828	Sync intmax_t and uintmax_t with C2x
3829	as_rvalue_view::end should improve non-common case
3830	reverse_view should not cache when ranges::next has constant time complexity
3831	Two-digit formatting of negative year is ambiguous
3832	Missing change for element_view::iterator in LWG 3798
3833	Remove specialization template<size_t N> struct formatter<const charT[N], charT>
3834	Missing constexpr for std::intmax_t math functions in <cinttypes>
3835	Requirements for CharT in the regex library
3836	std::expected<bool, E1> conversion constructor expected(const expected<U, G>&) should take precedence over expected(U&&) with operator bool
3837	std::erase_if overloads for non-associative containers should move (and not copy) their predicate object
3838	The last specialization of incrementable_traits is under-constrained
3839	range_formatter's set_separator, set_brackets, and underlying functions should be noexcept
3840	filesystem::u8path should be undeprecated
3841	<version> should not be "all freestanding"
3842	Unclear wording for precision in chrono-format-spec
3843	std::expected<T,E>::value() & assumes E is copy constructible
3844	Non-numeric formats for negative durations
3845	ranges::to's from_range_t tag branch has the wrong constraint
3846	iota_view::iterator::operator- is overconstrained
3847	ranges::to can still return views
3848	adjacent_view, adjacent_transform_view and slide_view missing base accessor
3849	cartesian_product_view::iterator's default constructor is overconstrained
3850	views::as_const on empty_view<T> should return empty_view<const T>
3851	chunk_view::inner-iterator missing custom iter_move and iter_swap
3852	join_with_view::iterator's iter_move and iter_swap should be conditionally noexcept
3853	basic_const_iterator<volatile int*>::operator-> is ill-formed
3854	§[res.on.exception.handling]/3 should not be applied to all standard library types
3855	tiny-range is not quite right
3856	Unclear which conversion specifiers are valid for each chrono type
3857	basic_string_view should allow explicit conversion when only traits vary
3858	basic_const_iterator is too strict to provide iterator_category
3859	std::projected cannot handle proxy iterator
3860	range_common_reference_t is missing
3861	mdspan layout_stride::mapping default constructor problem
3862	basic_const_iterator's common_type specialization is underconstrained
3863	Is input_iterator guaranteed to have iter_const_reference_t?
3864	zip over range of reference to an abstract type
3865	Sorting a range of pairs
3866	Bad Mandates for expected::transform_error overloads
3867	Should std::basic_osyncstream's move assignment operator be noexcept?
3868	Constrained algorithms should not require output_iterator
3869	Deprecate std::errc constants related to UNIX STREAMS
3870	Remove voidify
3871	Adjust note about terminate
3872	basic_const_iterator should have custom iter_move
3873	join_with_view's const begin is underconstrained
3874	Rename __cpp_lib_ranges_to_container to __cpp_lib_ranges_to
3875	std::ranges::repeat_view<T, IntegerClass>::iterator may be ill-formed
3876	Default constructor of std::layout_XX::mapping misses precondition
3877	Incorrect constraints on const-qualified monadic overloads for std::expected
3878	import std; should guarantee initialization of standard iostreams objects
3879	erase_if for flat_{,multi}set is incorrectly specified
3880	Clarify operator+= complexity for {chunk,stride}_view::iterator
3881	Incorrect formatting of container adapters backed by std::string
3882	tuple relational operators have confused friendships
3883	§[support.c.headers.other] Ambiguity in the requirements for includes
3884	flat_foo is missing allocator-extended copy/move constructors
3885	'op' should be in [zombie.names]
3886	Monad mo' problems
3887	Version macro for allocate_at_least
3888	Most ranges uninitialized memory algorithms are underconstrained
3889	std::(ranges::)destroy_at should destroy array elements in the decreasing index order
3890	ABI issue for integer-class types
3891	LWG 3870 breaks std::expected<cv T, E>
3892	Incorrect formatting of nested ranges and tuples
3893	LWG 3661 broke atomic<shared_ptr<T>> a; a = nullptr;
3894	generator::promise_type::yield_value(ranges::elements_of<Rng, Alloc>) should not be noexcept
3895	Various relation concepts are missing default values of the second template parameters
3896	The definition of viewable_range is not quite right
3897	inout_ptr will not update raw pointer to 0
3898	Possibly unintended preconditions for completion functions of std::barrier
3899	co_yielding elements of an lvalue generator is unnecessarily inefficient
3900	The allocator_arg_t overloads of generator::promise_type::operator new should not be constrained
3901	Is uses-allocator construction of a cv-qualified object type still well-formed after LWG 3870?
3902	Return type of std::declval<cv void> should be (cv-unqualified) void
3903	span destructor is redundantly noexcept
3904	lazy_split_view::outer-iterator's const-converting constructor isn't setting trailing_empty_
3905	Type of std::fexcept_t
3906	"Undefined address" is undefined
3907	Can iterator types of range adaptors and range factories be SCARY?
3908	enumerate_view::iterator constructor is explicit
3909	Issues about viewable_range
3910	The effects of including <iostream> on initialization are not yet precisely specified
3911	unique_ptr's operator* is missing a mandate
3912	enumerate_view::iterator::operator- should be noexcept
3913	ranges::const_iterator_t<range R> fails to accept arrays of unknown bound
3914	Inconsistent template-head of ranges::enumerate_view
3915	Redundant paragraph about expression variations
3916	allocator, polymorphic_allocator, and containers should forbid cv-qualified types
3917	Validity of allocator<void> and possibly polymorphic_allocator<void> should be clarified
3918	std::uninitialized_move/_n and guaranteed copy elision
3919	enumerate_view may invoke UB for sized common non-forward underlying ranges
3920	Bad footnotes claiming external linkage for entities defined as macros
3921	Is std::chrono::duration<std::int64_t, std::ratio<INT64_MAX - 1, INT64_MAX>>{40} required to be correctly formatted?
3922	It's unclear whether numeric_limits can be specialized by users
3923	The specification of numeric_limits doesn't clearly distinguish between implementation requirements and user requirements
3924	Stop token data race avoidance requirements unclear
3925	Concept formattable's definition is incorrect
3926	Which namespace std is the mentioned one?
3927	Unclear preconditions for operator[] for sequence containers
3928	Non-top-level namespace posix shouldn't be reserved
3929	Preconditions for type traits should be Mandates
3930	Simplify type trait wording
3931	Too many paper bump __cpp_lib_ranges
3932	Expression-equivalence is sometimes unimplementable when passing prvalue expressions to comparison CPOs
3933	P1467R9 accidentally changed the signatures of certain constructors of std::complex
3934	std::complex<T>::operator=(const T&) has no specification
3935	template<class X> constexpr complex& operator=(const complex<X>&) has no specification
3936	Are implementations allowed to deprecate components not in [depr]?
3937	I/O manipulators should be specified in terms of base classes
3938	Cannot use std::expected monadic ops with move-only error_type
3939	§[format.string.std] char is not formatted as a character when charT is wchar_t
3940	std::expected<void, E>::value() also needs E to be copy constructible
3941	§[atomics.order] inadvertently prohibits widespread implementation techniques
3942	Inconsistent use of const char_type& in standard specializations of std::char_traits
3943	Clarify lifetime requirements of BasicFormatter and Formatter
3944	Formatters converting sequences of char to sequences of wchar_t
3945	§[cstdarg.syn] 'Compatible types' are undefined
3946	The definition of const_iterator_t should be reworked
3947	Unexpected constraints on adjacent_transform_view::base()
3948	possibly-const-range and as-const-pointer should be noexcept
3949	std::atomic<bool>'s trivial destructor dropped in C++17 spec wording
3950	std::basic_string_view comparison operators are overspecified
3951	§[expected.object.swap]: Using value() instead of has_value()
3952	iter_common_reference_t does not conform to the definition of indirectly_readable
3953	iter_move for common_iterator and counted_iterator should return decltype(auto)
3954	Feature-test macros in C headers (<stddef.h> etc.)
3955	Add noexcept to several repeat_view[::iterator] member functions
3956	chrono::parse uses from_stream as a customization point
3957	§[container.alloc.reqmts] The value category of v should be claimed
3958	ranges::to should prioritize the "reserve" branch
3959	Should the comparator of std::flat_map/std::flat_multimap be copied twice in some operations?
3960	How does chrono::parse handle duplicated data?
3961	Does chrono::parse check format strings?
3962	What is the "decimal precision of the input"?
3963	Different std::flat_map/std::flat_multimap specializations should be able to share same nested classes
3964	std::atan2 and std::pow overloads that take two std::valarray parameters should require the arguments to have the same length
3965	Incorrect example in [format.string.escaped] p3 for formatting of combining characters
3966	The value_type and reference members of std::flat_(multi)map::(const_)iterator are unclear
3967	The specification for std::is_nothrow_* traits may be ambiguous in some cases involving noexcept(false)
3968	std::endian::native value should be more specific about object representations
3969	std::ranges::fold_left_first_with_iter should be more ADL-proof
3970	§[mdspan.syn] Missing definition of full_extent_t and full_extent
3971	Join ranges of rvalue references with ranges of prvalues
3972	Issues with join_with_view::iterator's iter_swap
3973	Monadic operations should be ADL-proof
3974	mdspan::operator[] should not copy OtherIndexTypes
3975	Specializations of basic_format_context should not be permitted
3976	What does it mean for a type to be "allocator aware"?
3977	constexpr and noexcept for operators for bitmask types
3978	The "no effect" requirement for std::ignore is unimplementable for volatile bit-fields
3979	Should we reject std::bind_front<42>() and its friends?
3980	The read exclusive ownership of an atomic read-modify-write operation and whether its read and write are two operations are unclear
3981	Range adaptor closure object is underspecified for its return type
3982	is-derived-from-view-interface should require that T is derived from view_interface<T>
3983	ranges::to adaptors are underconstrained
3984	ranges::to's recursion branch may be ill-formed
3985	ranges::to should Mandates C not to be view
3986	basic_const_iterator doesn't work with optional
3987	Including <flat_foo> doesn't provide std::begin/end
3988	Should as_const_view and basic_const_iterator provide base()?
3989	The whole range for an iterator obtained from a std::span or std::basic_string_view is not clear
3990	Program-defined specializations of std::tuple and std::variant can't be properly supported
3991	variant's move assignment should not be guaranteed to produce a valueless by exception state
3992	basic_stringbuf::str()&& should enforce 𝒪(1)
3993	The parse function of a BasicFormatter type needs to be constexpr
3994	adaptor(args...)(r) is not equivalent to std::bind_back(adaptor, args...)(r)
3995	Issue with custom index conversion in <mdspan>
3996	projected<I, identity> should just be I
3997	std::formatter specializations should be consistently restricted to supported character types
3998	Constants in std::regex_constants should be allowed to be enumerators
3999	P0439R0 changed the value category of memory order constants
4000	flat_map::insert_range's Effects is not quite right
4001	iota_view should provide empty
4002	The definition of iota_view::iterator::iterator_concept should be improved
4003	view_interface::back is overconstrained
4004	The load and store operation in §[atomics.order] p1 is ambiguous
4005	"Required behavior" too narrowly defined
4006	chunk_view::outer-iterator::value_type should provide empty
4007	Mystic prohibition of calling a volatile-qualified perfect forwarding call wrapper
4008	§[range.utility.conv.to] ranges::to may cause infinite recursion if range_value_t<C> is a non-move-constructible range
4009	drop_view::begin const may have 𝒪(n) complexity
4010	subrange::advance should be improved
4011	"Effects: Equivalent to return" in [span.elem]
4012	common_view::begin/end are missing the simple-view check
4013	lazy_split_view::outer-iterator::value_type should not provide default constructor
4014	LWG 3809 changes behavior of some existing std::subtract_with_carry_engine code
4015	LWG 3973 broke const overloads of std::optional monadic operations
4016	container-insertable checks do not match what container-inserter does
4017	Behavior of std::views::split on an empty range
4018	ranges::to's copy branch is underconstrained
4019	Reversing an infinite range leads to an infinite loop
4020	extents::index-cast weirdness
4021	mdspan::is_always_meow() should be noexcept
4022	Ambiguity in the formatting of negative years with format specifier %C
4023	Preconditions of std::basic_streambuf::setg/setp
4024	Underspecified destruction of objects created in std::make_shared_for_overwrite/std::allocate_shared_for_overwrite
4025	Move assignment operator of std::expected<cv void, E> should not be conditionally deleted
4026	Assignment operators of std::expected should propagate triviality
4027	possibly-const-range should prefer returning const R&
4028	std::is_(nothrow_)convertible should be reworded to avoid dependence on the return statement
4029	basic_string accidentally fails to meet the reversible container requirements
4030	Clarify whether arithmetic expressions in [numeric.sat.func] are mathematical or C++
4031	bad_expected_access<void> member functions should be noexcept
4032	Possibly invalid types in the constraints of constructors of std::shared_ptr
4033	§[macro.names] defining macros after importing the standard library
4034	Clarify specification of std::min and std::max
4035	single_view should provide empty
4036	__alignof_is_defined is only implicitly specified in C++ and not yet deprecated
4037	Static data members of ctype_base are not yet required to be usable in constant expressions
4038	std::text_encoding::aliases_view should have constexpr iterators
4039	§[ostream.formatted.print]: Inappropriate usage of badbit in definition of vprint_unicode/vprint_nonunicode
4040	Contradictory specification of std::tuple_size
4041	The requirements on literal type in [concept.swappable] should be removed
4042	std::print should permit an efficient implementation
4043	"ASCII" is not a registered character encoding
4044	Confusing requirements for std::print on POSIX platforms
4045	tuple can create dangling references from tuple-like
4046	Effects of inserting into or erasing from flat container adaptors when an exception is thrown need to be more permissive
4047	Explicitly specifying template arguments for std::swap should not be supported
4048	Inconsistent preconditions for transparent insertion of std::flat_map/std::flat_set
4049	C <foo.h> headers not in freestanding
4050	Should views::iota(0) | views::take(5) be views::iota(0, 5)?
4051	A less hacky and more useful way to compare comparison category types
4052	Bogus requirements for piecewise_linear_distribution
4053	Unary call to std::views::repeat does not decay the argument
4054	Repeating a repeat_view should repeat the view
4055	§[iterator.operations] std::distance is missing a precondition
4056	The effects of std::swap are under-specified
4057	generator::iterator's operator* is not noexcept when it can be
4058	std::to_address() should be SFINAE-friendly
4059	Leaky abstraction in join_with_view's iterator
4060	submdspan preconditions do not forbid creating invalid pointer
4061	Should std::basic_format_context be default-constructible/copyable/movable?
4062	ranges::empty has no semantic requirements for forward_ranges
4063	Freestanding std::char_traits<char>::eof depends on non-freestanding EOF
4064	Clarify that std::launder is not needed when using the result of std::memcpy
4065	Requirements for fancy pointers might be insufficient for self-referential implementation of containers
4066	ranges::to should reserve when sized_sentinel_for is satisfied
4067	Inconsistency and potential infinity meta-recursion in std::chrono::zoned_time's constructors
4068	Terminology for objects whose types model a concept
4069	std::atomic<volatile T> should be ill-formed
4070	Transcoding by std::formatter<std::filesystem::path>
4071	reference_wrapper comparisons are not SFINAE-friendly
4072	`std::optional` comparisons: constrain harder
4073	`concat_view::size` may overflow
4074	compatible-joinable-ranges is underconstrained
4075	Thread stability requirement on constructors and destructors
4076	concat_view should be freestanding
4077	Unclear preconditions of `std::ranges::generate_random`
4078	What if arguments alias the output buffer in `std::format_to`?
4079	Missing Preconditions in concat_view::iterator's conversion constructor
4080	Presumed value and difference types of an iterator type in ranges and non-ranges algorithms
4081	concat_view::iterator::operator- is overconstrained
4082	views::concat(r) is well-formed when r is an output_range
4083	views::as_rvalue should reject non-input ranges
4084	std::fixed ignores std::uppercase
4085	ranges::generate_random's helper lambda should specify the return type
4086	ranges::generate_random_n is missing
4087	Standard exception messages have unspecified encoding
4088	println ignores the locale imbued in std::ostream
4089	concat_view::iterator's iter_swap is overconstrained
4090	Underspecified use of locale facets for locale-dependent std::format
4091	concat_view rejects non-movable references
4092	The monotonic version of common_iterator::operator== is underconstrained
4093	ranges::fold_left_first_with_iter incorrectly constructs optional<U>
4094	ranges::fold_meow is overconstrained
4095	ranges::fold_meow should explicitly spell out the return type
4096	views::iota(views::iota(0)) should be rejected
4097	views::reverse should be specialized for some view types
4098	views::adjacent<0> should reject non-forward ranges
4099	The simple case of views::as_rvalue and views::common are not strictly correct
4100	Default arguments and signatures of standard library non-member functions
4101	LWG 117 loses the sign for negative NaN on some architectures
4102	`string_view(Iter, Iter)` constructor breaks existing code
4103	ranges::unique_copy's constraints for the case where result is an input_iterator are not quite right
4104	basic_const_iterator<volatile int*> is not a contiguous_iterator
4105	ranges::ends_with's Returns misses difference casting
4106	basic_format_args should not be default-constructible
4107	Map formatter may conflict with user-defined specializations of pair/tuple formatters
4108	lazy_split_view should be sized_range when pattern is empty tiny-range
4109	Instantiating templates in §[rand] with int8_t/uint8_t is undefined behavior
4110	`shared_ptr(nullptr_t, Deleter)` is overconstrained, breaking some sensible deleters
4111	LWG 270 and ranges version of binary search algorithms
4112	has-arrow should required operator->() to be const-qualified
4113	Disallow has_unique_object_representations<Incomplete[]>
4114	elements_view::iterator::operator* missing conditional noexcept specification
4115	move_iterator::operator* should have conditional noexcept specification
4116	enumerate_view::iterator and cartesian_product_view::iterator should not always provide iterator_category
4117	generator::iterator should provide iterator_concept
4118	How should `duration` formatters format custom `rep` types?
4119	generator::promise_type::yield_value(ranges::elements_of<R, Alloc>)'s nested generator may be ill-formed
4120	move_iterator should provide iterator_category only when it models forward_iterator
4121	ranges::to constructs associative containers via c.emplace(c.end(), *it)
4122	Ill-formed operator<=> can cause hard error when instantiating std::inplace_vector
4123	Container effects use "the assignment operator or move assignment operator"
4124	Cannot format `zoned_time` with resolution coarser than seconds
4125	move_iterator's default constructor should be constrained
4126	Some feature-test macros for fully freestanding features are not yet marked freestanding
4127	The Standard Library should not use predicates of the form pred(*i) != false
4128	Allocator requirements should not allow rebinding conversions to be explicit
4129	Possibly incorrect wording for data race avoidance
4130	Preconditions for std::launder might be overly strict
4131	Including <optional> doesn't provide std::begin/end
4132	Throws specifications need to include boolean-testable operations
4133	awaitable-receiver's members are potentially throwing
4134	Issue with Philox algorithm specification
4135	The helper lambda of std::erase for list should specify return type as bool
4136	Specify behavior of [linalg] Hermitian algorithms on diagonal with nonzero imaginary part
4137	Fix Mandates, Preconditions, and Complexity elements of [linalg] algorithms
4138	is_within_lifetime should mandate is_object
4139	§[time.zone.leap] recursive constraint in <=>
4140	Useless default constructors for bit reference types
4141	Improve prohibitions on "additional storage"
4142	format_parse_context::check_dynamic_spec should require at least one type
4143	execution::set_value/set_error/set_stopped/start should always return void
4144	Disallow unique_ptr<T&, D>
4145	Unclear how [res.on.data.races] apply to templated functions
4146	§[format.formatter.spec]/3 unconditionally enables nonlocking for container adaptors
4147	Precondition on inplace_vector::emplace
4148	unique_ptr::operator* should not allow dangling references
4149	User defined macros without standard headers (294 redux)
4150	The preconditions on run_loop::run() are too strict
4151	Precondition of inplace_vector::swap
4152	The primary template of std::char_traits is totally underspecified
4153	Fix extra "-1" for philox_engine::max()
4154	The Mandates for std::packaged_task's constructor from a callable entity should consider decaying
4155	Cpp17NullablePointer should require that some expression can be contextually converted to bool
4156	error_category messages have unspecified encoding
4157	The resolution of LWG3465 was damaged by P2167R3
4158	packaged_task::operator= should abandon its shared state
4159	Uses-allocator construction mechanisms should be opted out for node handles
4160	packaged_task should reject rvalue reference return types
4161	Some free functions don't automatically work for program-defined std::complex<NonFloatingPoint>
4162	Worst time complexity of non-parallel versions of nth_element is underspecified
4163	Can the overload of std::num_get::do_get for bool call the overload for long?
4164	Missing guarantees for `forward_list` modifiers
4165	Should swapping a built-in array or `std::array` with itself result in UB?
4166	`concat_view::end()` should be more constrained in order to support noncopyable iterators
4167	Use of "smaller" and "larger" in min, max, and minmax is unclear
4168	`std::start_lifetime_as` inadvertently has undefined behavior due to use of `std::bit_cast`
4169	std::atomic<T>'s default constructor should be constrained
4170	`contiguous_iterator` should require `to_address(I{})`
4171	P2609R3 breaks code that uses `views::zip` and get<T>
4172	unique_lock self-move-assignment is broken

---

Sort on

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending

Group on

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending