[www] Change URLs to HTTPS.

[STL_MSFT]

Summary

This changes most URLs in llvm's html files to HTTPS. Most changes were search-and-replace with manual verification; some changes were manual. For a few URLs, the websites were performing redirects or had changed their anchors; I fixed those up manually. There are a very small number of dead links for which I don't know any replacements (they are equally dead as HTTP or HTTPS).

I have this structured as a series of git commits with mechanical and manual replacements separated, but I don't know how to present that through Differential (as GitHub PRs aren't available yet).

[zoecarver]

GitHub PRs can't come soon enough :) There was a round table meeting about that earlier today which I am anxious to hear about.

clang/www/cxx_status.html

78

These will all now redirect. Maybe that's OK/better because they are now more uniform, though.

[ldionne]

Nice!

[STL_MSFT]

clang/www/cxx_status.html

78

Yep, that's intentional for consistency with the newer papers that were already using the official redirector. (It's my hope that open-std will eventually support https so the destination is secure; if and when that happens, these will automatically be enhanced.)

[zoecarver]

Thanks for updating all these links! LGTM :)

clang/www/cxx_status.html

78

Makes sense, especially if (when?) papers are updated the links will be auto-updated too (like you said).

[STL_MSFT]

Committed: https://github.com/llvm/llvm-project/commit/2e4f1e112dfee1d16c138d42f2bc7ee639f9ae05

clang/www/OpenProjects.html

 use the same preprocessor/parser/ASTs as the compiler itself, giving it a very
 rich understanding of the code. Clang is already able to read and understand
 doxygen markup, but cannot yet generate documentation from it.</li>
 
 <li><b>Use clang libraries to implement better versions of existing tools</b>:
 Clang is built as a set of libraries, which means that it is possible to
 implement capabilities similar to other source language tools, improving them
 in various ways.  Three examples are <a
-href="http://distcc.samba.org/">distcc</a>, the <a
+href="https://github.com/distcc">distcc</a>, the <a
 href="http://delta.tigris.org/">delta testcase reduction tool</a>, and the
 "indent" source reformatting tool.
 distcc can be improved to scale better and be more efficient.  Delta could be
 faster and more efficient at reducing C-family programs if built on the clang
 preprocessor. The clang-based indent replacement,
-<a href="http://clang.llvm.org/docs/ClangFormat.html">clang-format</a>,
+<a href="https://clang.llvm.org/docs/ClangFormat.html">clang-format</a>,
 could be taught to handle simple structural rules like those in <a
-href="http://llvm.org/docs/CodingStandards.html#hl_earlyexit">the LLVM coding
+href="https://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code">the LLVM coding
 standards</a>.</li>
 
-<li><b>Use clang libraries to extend Ragel with a JIT</b>: <a 
-href="http://research.cs.queensu.ca/~thurston/ragel/">Ragel</a> is a state
+<li><b>Use clang libraries to extend Ragel with a JIT</b>: <a
+href="https://www.colm.net/open-source/ragel/">Ragel</a> is a state
 machine compiler that lets you embed C code into state machines and generate
 C code.  It would be relatively easy to turn this into a JIT compiler using
 LLVM.</li>
 
 <li><b>Self-testing using clang</b>: There are several neat ways to
 improve the quality of clang by self-testing. Some examples:
 <ul>
   <li>Improve the reliability of AST printing and serialization by

clang/www/UniversalDriver.html

 developers, operating system distribution vendors and the development community
 at large. Our plan is to begin by defining a clear list of the problems we want
 to solve and a proposed implementation (from the user perspective).</p>
 
 <p>This project is in the very early (i.e., thought experiment) stages of
 development. Stay tuned for more information, and of course, patches
 welcome!</p>
 
-<p>See also <a href="http://llvm.org/PR4127">PR4127</a>.</p>
+<p>See also <a href="https://llvm.org/PR4127">PR4127</a>.</p>
 
 <h2>Existing Solutions and Related Work</h2>
 
 <ul>
   <li>gcc's command line arguments <tt>-V</tt>, <tt>-B</tt>, <tt>-b</tt> are
     generic but limited solutions to related problems. Similarly, <tt>-m32</tt>
     and <tt>-m64</tt> solve a small subset of the problem for specific
     architectures.</li>
 
-  <li>gcc's <a href="http://www.airs.com/ian/configure/configure_8.html">multilibs</a>
+  <li>gcc's <a href="https://www.airs.com/ian/configure/configure_8.html">multilibs</a>
     solve the part of the problem that relates to finding appropriate libraries
     and include files based on particular feature support (soft float,
     etc.).</li>
 
   <li>Apple's "driver driver" supported by gcc and clang solve a subset of the
     problem by supporting <tt>-arch</tt>. Apple also provides a tool chain which
-    supports <a href="http://en.wikipedia.org/wiki/Universal_binary">universal
+    supports <a href="https://en.wikipedia.org/wiki/Universal_binary">universal
     binaries</a> and object files which may include data for multiple
     architectures. See <a href="http://developer.apple.com/mac/library/technotes/tn2005/tn2137.html">TN2137</a>
     for an example of how this is used.</li>
 
   <li>Many operating systems and environments solve the problem by installing
     complete development environments (including the IDE, tools, header files,
     and libraries) for a single tool chain. This is cumbersome for users and
     does not match well with tools which are inherently capable of cross
     compiling.</li>
 
-  <li>The Debian <a href="http://wiki.debian.org/ArmEabiPort">ArmEabiPort</a>
+  <li>The Debian <a href="https://wiki.debian.org/ArmEabiPort">ArmEabiPort</a>
     wiki page for their work to support the ARM EABI provide an interesting
     glimpse into how related issues impact the operating system distribution.</li>
 
   <li><a href="http://icculus.org/fatelf/">FatELF</a> is a proposal for bringing
     Mac OS X like "Universal Binary" support to ELF based platforms.</li>
 
 </ul>
 
 </div>
 </body>
 </html>

clang/www/analyzer/alpha_checks.html

 
 
 <tr><td><a id="alpha.unix.SimpleStream"><div class="namedescr expandable"><span class="name">
 alpha.unix.SimpleStream</span><span class="lang">
 (C)</span><div class="descr">
 Check for misuses of stream APIs:<div class=functions>
 fopen<br>
 fclose</div>(demo checker, the subject of the demo
-(<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
+(<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
 ,<a href="https://youtu.be/kdxlsP5QVPw">Video</a>)
-by Anna Zaks and Jordan Rose presented at the <a href="http://llvm.org/devmtg/2012-11/">
+by Anna Zaks and Jordan Rose presented at the <a href="https://llvm.org/devmtg/2012-11/">
 2012 LLVM Developers' Meeting).</a></div></div></a></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void test() {
   FILE *F = fopen("myfile.txt", "w");
 } // warn: opened file is never closed
 </pre></div><div class="separator"></div>
 <div class="example"><pre>

clang/www/analyzer/annotations.html

 <div id="page">
 <!--#include virtual="menu.html.incl"-->
 
 <div id="content">
 
 <h1>Source Annotations</h1>
 
 <p>The Clang frontend supports several source-level annotations in the form of
-<a href="http://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html">GCC-style
+<a href="https://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html">GCC-style
 attributes</a> and pragmas that can help make using the Clang Static Analyzer
 more useful. These annotations can both help suppress false positives as well as
 enhance the analyzer's ability to find bugs.</p>
 
 <p>This page gives a practical overview of such annotations. For more technical
 specifics regarding Clang-specific annotations please see the Clang's list of <a
-href="http://clang.llvm.org/docs/LanguageExtensions.html">language
+href="https://clang.llvm.org/docs/LanguageExtensions.html">language
 extensions</a>. Details of &quot;standard&quot; GCC attributes (that Clang also
-supports) can be found in the <a href="http://gcc.gnu.org/onlinedocs/gcc/">GCC
+supports) can be found in the <a href="https://gcc.gnu.org/onlinedocs/gcc/">GCC
 manual</a>, with the majority of the relevant attributes being in the section on
-<a href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html">function
+<a href="https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html">function
 attributes</a>.</p>
 
 <p>Note that attributes that are labeled <b>Clang-specific</b> are not
 recognized by GCC. Their use can be conditioned using preprocessor macros
 (examples included on this page).</p>
 
 <h4>Specific Topics</h4>
 
<ul>
     <li><a href="#osobject_mem">Libkern Memory Management Annotations</a>
       <ul>
         <li><a href="#attr_os_returns_retained">Attribute 'os_returns_retained'</a></li>
         <li><a href="#attr_os_returns_not_retained">Attribute 'os_returns_not_retained'</a></li>
         <li><a href="#attr_os_consumed">Attribute 'os_consumed'</a></li>
         <li><a href="#attr_os_consumes_this">Attribute 'os_consumes_this'</a></li>
         <li><a href="#os_out_parameters">Out Parameters</a></li>
       </ul>
-    
     </li>
   </ul>
 </li>
 <li><a href="#custom_assertions">Custom Assertion Handlers</a>
   <ul>
     <li><a href="#attr_noreturn">Attribute 'noreturn'</a></li>
     <li><a href="#attr_analyzer_noreturn">Attribute 'analyzer_noreturn'</a></li>
   </ul>
   </li>
 </ul>
 
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 <h2 id="generic">Annotations to Enhance Generic Checks</h2>
 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
 
 <h3 id="null_checking">Null Pointer Checking</h3>
 
 <h4 id="attr_nonnull">Attribute 'nonnull'</h4>
 
 <p>The analyzer recognizes the GCC attribute 'nonnull', which indicates that a
 function expects that a given function parameter is not a null pointer. Specific
 details of the syntax of using the 'nonnull' attribute can be found in <a
-href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bnonnull_007d-function-attribute-2263">GCC's
+href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-nonnull-function-attribute">GCC's
 documentation</a>.</p>
 
 <p>Both the Clang compiler and GCC will flag warnings for simple cases where a
 null pointer is directly being passed to a function with a 'nonnull' parameter
 (e.g., as a constant). The analyzer extends this checking by using its deeper
 symbolic analysis to track what pointer values are potentially null and then
 flag warnings when they are passed in a function call via a 'nonnull'
 parameter.</p>
 
 <p><b>Example</b></p>
 
 <pre class="code_example">
 <span class="command">$ cat test.m</span>
 int bar(int*p, int q, int *r) __attribute__((nonnull(1,3)));
 
 int foo(int *p, int *q) {
-   return !p ? bar(q, 2, p) 
+   return !p ? bar(q, 2, p)
              : bar(p, 2, q);
 }
 </pre>
 
 <p>Running <tt>scan-build</tt> over this source produces the following
 output:</p>
 
 <img src="images/example_attribute_nonnull.png" alt="example attribute nonnull">

 both Cocoa and Core Foundation objects. This checking is largely based on
 enforcing Cocoa and Core Foundation naming conventions for Objective-C methods
 (Cocoa) and C functions (Core Foundation). Not strictly following these
 conventions can cause the analyzer to miss bugs or flag false positives.</p>
 
 <p>One can educate the analyzer (and others who read your code) about methods or
 functions that deviate from the Cocoa and Core Foundation conventions using the
 attributes described here. However, you should consider using proper naming
-conventions or the <a 
-href="http://clang.llvm.org/docs/LanguageExtensions.html#the-objc-method-family-attribute"><tt>objc_method_family</tt></a>
+conventions or the <a
+href="https://clang.llvm.org/docs/LanguageExtensions.html#the-objc-method-family-attribute"><tt>objc_method_family</tt></a>
 attribute, if applicable.</p>
 
 <h4 id="attr_ns_returns_retained">Attribute 'ns_returns_retained'
 (Clang-specific)</h4>
 
 <p>The GCC-style (Clang-specific) attribute 'ns_returns_retained' allows one to
 annotate an Objective-C method or C function as returning a retained Cocoa
 object that the caller is responsible for releasing (via sending a

 #endif
 </pre>
 
 <h4 id="attr_cf_returns_retained">Attribute 'cf_returns_retained'
 (Clang-specific)</h4>
 
 <p>The GCC-style (Clang-specific) attribute 'cf_returns_retained' allows one to
 annotate an Objective-C method or C function as returning a retained Core
-Foundation object that the caller is responsible for releasing. The 
+Foundation object that the caller is responsible for releasing. The
 CoreFoundation framework defines a macro <b><tt>CF_RETURNS_RETAINED</tt></b>
 that is functionally equivalent to the one shown below.</p>
 
 <p><b>Placing on Objective-C methods</b>: With respect to Objective-C methods.,
 this attribute is identical in its behavior and usage to 'ns_returns_retained'
 except for the distinction of returning a Core Foundation object instead of a
 Cocoa object.
 

 <h4 id="attr_cf_returns_not_retained">Attribute 'cf_returns_not_retained'
 (Clang-specific)</h4>
 
 <p>The 'cf_returns_not_retained' attribute is the complement of '<a
 href="#attr_cf_returns_retained">cf_returns_retained</a>'. Where a function or
 method may appear to obey the Core Foundation or Cocoa conventions and return
 a retained Core Foundation object, this attribute can be used to indicate that
 the object reference returned should not be considered as an
-&quot;owning&quot; reference being returned to the caller. The 
+&quot;owning&quot; reference being returned to the caller. The
 CoreFoundation framework defines a macro <b><tt>CF_RETURNS_NOT_RETAINED</tt></b>
 that is functionally equivalent to the one shown below.</p>
 
 <p>Usage is identical to <a
 href="#attr_cf_returns_retained">cf_returns_retained</a>.  When using the
 attribute, be sure to declare it within the proper macro that checks for
 its availability, as it is not available in earlier versions of the analyzer:</p>
 

 </pre>
 
 <h4 id="attr_ns_consumed">Attribute 'ns_consumed'
 (Clang-specific)</h4>
 
 <p>The 'ns_consumed' attribute can be placed on a specific parameter in either
 the declaration of a function or an Objective-C method. It indicates to the
 static analyzer that a <tt>release</tt> message is implicitly sent to the
-parameter upon completion of the call to the given function or method. The 
-Foundation framework defines a macro <b><tt>NS_RELEASES_ARGUMENT</tt></b> that 
+parameter upon completion of the call to the given function or method. The
+Foundation framework defines a macro <b><tt>NS_RELEASES_ARGUMENT</tt></b> that
 is functionally equivalent to the <tt>NS_CONSUMED</tt> macro shown below.</p>
 
 <p><b>Example</b></p>
 
 <pre class="code_example">
 <span class="command">$ cat test.m</span>
 #ifndef __has_feature      // Optional.
 #define __has_feature(x) 0 // Compatibility with non-clang compilers.

 <p>The 'cf_consumed' attribute is practically identical to <a
 href="#attr_ns_consumed">ns_consumed</a>. The attribute can be placed on a
 specific parameter in either the declaration of a function or an Objective-C
 method. It indicates to the static analyzer that the object reference is
 implicitly passed to a call to <tt>CFRelease</tt> upon completion of the call
 to the given function or method. The CoreFoundation framework defines a macro
 <b><tt>CF_RELEASES_ARGUMENT</tt></b> that is functionally equivalent to the
 <tt>CF_CONSUMED</tt> macro shown below.</p>
-    
 <p>Operationally this attribute is nearly identical to 'ns_consumed'.</p>
 
 <p><b>Example</b></p>
 
 <pre class="code_example">
 <span class="command">$ cat test.m</span>
 #ifndef __has_feature      // Optional.
 #define __has_feature(x) 0 // Compatibility with non-clang compilers.

 void test() {
   id x = [[NSObject alloc] init];
   consume_cf(x); <b><i>// No leak!</i></b>
 }
 
 void test2() {
   CFDateRef date = CFDateCreate(0, CFAbsoluteTimeGetCurrent());
   consume_CFDate(date); <b><i>// No leak, including under GC!</i></b>
-  
 }
 
 @interface Foo : NSObject
 + (void) releaseArg:(CFDateRef) <span class="code_highlight">CF_CONSUMED</span> x;
 @end
 
 void test_method() {
   CFDateRef date = CFDateCreate(0, CFAbsoluteTimeGetCurrent());
   [Foo releaseArg:date]; <b><i>// No leak!</i></b>
 }
 </pre>
 
 <h4 id="attr_ns_consumes_self">Attribute 'ns_consumes_self'
 (Clang-specific)</h4>
 
 <p>The 'ns_consumes_self' attribute can be placed only on an Objective-C method
 declaration. It indicates that the receiver of the message is
 &quot;consumed&quot; (a single reference count decremented) after the message
 is sent. This matches the semantics of all &quot;init&quot; methods.</p>
 
 <p>One use of this attribute is declare your own init-like methods that do not
 follow the standard Cocoa naming conventions.</p>
 
 <p><b>Example</b></p>
-  
 <pre class="code_example">
 #ifndef __has_feature
 #define __has_feature(x) 0 // Compatibility with non-clang compilers.
 #endif
 
 #ifndef NS_CONSUMES_SELF
 #if __has_feature((attribute_ns_consumes_self))
 <span class="code_highlight">#define NS_CONSUMES_SELF __attribute__((ns_consumes_self))</span>

 
 <h5>Example</h5>
 
 <pre class="code_example">
 class MyClass {
   OSObject *f;
   LIBKERN_RETURNS_NOT_RETAINED OSObject *myFieldGetter();
 }
- 
- 
 // Note that the annotation only has to be applied to the function declaration.
 OSObject * MyClass::myFieldGetter() {
   return f;
 }
 </pre>
 
 <h4 id="attr_os_consumed">Attribute 'os_consumed'</h4>
 

 caller has no further obligations.</p>
 
 <p><b>2. Retained out parameters</b>,
 identified using <tt>LIBKERN_RETURNS_RETAINED</tt>:</p>
 <pre class="code_example">
 void getterViaOutParam(LIBKERN_RETURNS_NOT_RETAINED OSObject **obj)
 </pre>
 <p>
-In such cases a retained object is written into an out parameter, which the caller has then to release in order to avoid a leak. 
+In such cases a retained object is written into an out parameter, which the caller has then to release in order to avoid a leak.
 </p>
 
 <p>These two cases are simple - but in practice a functions returning an out-parameter usually also return a return code, and then an out parameter may or may not be written, which conditionally depends on the exit code, e.g.:</p>
 
 <pre class="code_example">
 bool maybeCreateObject(LIBKERN_RETURNS_RETAINED OSObject **obj);
 </pre>
 

 returns and it will continue analyzing the path where the assertion condition
 failed. This can lead to false positives, as the assertion condition usually
 implies a safety condition (e.g., a pointer is not null) prior to performing
 some action that depends on that condition (e.g., dereferencing a pointer).</p>
 
 <p>The analyzer knows about several well-known assertion handlers, but can
 automatically infer if a function should be treated as an assertion handler if
 it is annotated with the 'noreturn' attribute or the (Clang-specific)
-'analyzer_noreturn' attribute. Note that, currently, clang does not support 
+'analyzer_noreturn' attribute. Note that, currently, clang does not support
 these attributes on Objective-C methods and C++ methods.</p>
 
 <h4 id="attr_noreturn">Attribute 'noreturn'</h4>
 
 <p>The 'noreturn' attribute is a GCC-attribute that can be placed on the
 declarations of functions. It means exactly what its name implies: a function
 with a 'noreturn' attribute should never return.</p>
 
 <p>Specific details of the syntax of using the 'noreturn' attribute can be found
 in <a
-href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bnoreturn_007d-function-attribute-2264">GCC's
+href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-noreturn-function-attribute">GCC's
 documentation</a>.</p>
 
 <p>Not only does the analyzer exploit this information when pruning false paths,
 but the compiler also takes it seriously and will generate different code (and
 possibly better optimized) under the assumption that the function does not
 return.</p>
 
 <p><b>Example</b></p>

clang/www/analyzer/available_checks.html

 <a href = "#default_checkers">Default Checkers</a> list below. In addition to
 these, the analyzer contains a number of <a href = "alpha_checks.html">
 Experimental (Alpha) Checkers</a>.
 
 <h3>Writeups with examples of some of the bugs that the analyzer finds</h3>
 <ul>
 <li><a href="http://www.mobileorchard.com/bug-finding-with-clang-5-resources-to-get-you-started/">Bug Finding With Clang: 5 Resources To Get You Started</a></li>
 <li><a href="http://fruitstandsoftware.com/blog/index.php/2008/08/finding-memory-leaks-with-the-llvmclang-static-analyzer/#comment-2">Finding Memory Leaks With The LLVM/Clang Static Analyzer</a></li>
-<li><a href="http://www.rogueamoeba.com/utm/2008/07/14/the-clang-static-analyzer/">Under the Microscope - The Clang Static Analyzer</a></li>
-<li><a href="http://www.mikeash.com/?page=pyblog/friday-qa-2009-03-06-using-the-clang-static-analyzer.html">Mike Ash - Using the Clang Static Analyzer</a></li>
+<li><a href="https://weblog.rogueamoeba.com/2008/07/14/the-clang-static-analyzer/">Under the Microscope - The Clang Static Analyzer</a></li>
+<li><a href="https://www.mikeash.com/pyblog/friday-qa-2009-03-06-using-the-clang-static-analyzer.html">Mike Ash - Using the Clang Static Analyzer</a></li>
 </ul>
 
 <h2 id="default_checkers">Default Checkers</h2>
 <ul>
 <li><a href="#core_checkers">Core Checkers</a> model core language features and perform general-purpose checks such as division by zero, null pointer dereference, usage of uninitialized values, etc.</li>
 <li><a href="#cplusplus_checkers">C++ Checkers</a> perform C++-specific checks</li>
 <li><a href="#deadcode_checkers">Dead Code Checkers</a> check for unused code</li>
 <li><a href="#nullability_checkers">Nullability Checkers</a> </li>

clang/www/analyzer/checker_dev_manual.html

 <!--#include virtual="menu.html.incl"-->
 
 <div id="content">
 
 <h3 style="color:red">This Page Is Under Construction</h3>
 
 <h1>Checker Developer Manual</h1>
 
-<p>The static analyzer engine performs path-sensitive exploration of the program and 
-relies on a set of checkers to implement the logic for detecting and 
-constructing specific bug reports. Anyone who is interested in implementing their own 
-checker, should check out the Building a Checker in 24 Hours talk 
-(<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
+<p>The static analyzer engine performs path-sensitive exploration of the program and
+relies on a set of checkers to implement the logic for detecting and
+constructing specific bug reports. Anyone who is interested in implementing their own
+checker, should check out the Building a Checker in 24 Hours talk
+(<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
  <a href="https://youtu.be/kdxlsP5QVPw">video</a>)
-and refer to this page for additional information on writing a checker. The static analyzer is a 
-part of the Clang project, so consult <a href="http://clang.llvm.org/hacking.html">Hacking on Clang</a> 
-and <a href="http://llvm.org/docs/ProgrammersManual.html">LLVM Programmer's Manual</a> 
-for developer guidelines and send your questions and proposals to 
-<a href=http://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev mailing list</a>. 
+and refer to this page for additional information on writing a checker. The static analyzer is a
+part of the Clang project, so consult <a href="https://clang.llvm.org/hacking.html">Hacking on Clang</a>
+and <a href="https://llvm.org/docs/ProgrammersManual.html">LLVM Programmer's Manual</a>
+for developer guidelines and send your questions and proposals to
+<a href=https://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev mailing list</a>.
 </p>
 
     <ul>
       <li><a href="#start">Getting Started</a></li>
       <li><a href="#analyzer">Static Analyzer Overview</a>
       <ul>
         <li><a href="#interaction">Interaction with Checkers</a></li>
         <li><a href="#values">Representing Values</a></li>
<ul>
         <li><a href="#debugprints">Debug Prints and Tricks</a></li>
       </ul></li>
       <li><a href="#additioninformation">Additional Sources of Information</a></li>
       <li><a href="#links">Useful Links</a></li>
     </ul>
 
 <h2 id=start>Getting Started</h2>
   <ul>
-    <li>To check out the source code and build the project, follow steps 1-4 of 
-    the <a href="http://clang.llvm.org/get_started.html">Clang Getting Started</a> 
+    <li>To check out the source code and build the project, follow steps 1-4 of
+    the <a href="https://clang.llvm.org/get_started.html">Clang Getting Started</a>
   page.</li>
 
     <li>The analyzer source code is located under the Clang source tree:
     <br><tt>
     $ <b>cd llvm/tools/clang</b>
     </tt>
     <br>See: <tt>include/clang/StaticAnalyzer</tt>, <tt>lib/StaticAnalyzer</tt>,
      <tt>test/Analysis</tt>.</li>
 
-    <li>The analyzer regression tests can be executed from the Clang's build 
+    <li>The analyzer regression tests can be executed from the Clang's build
     directory:
     <br><tt>
     $ <b>cd ../../../; cd build/tools/clang; TESTDIRS=Analysis make test</b>
     </tt></li>
-    
     <li>Analyze a file with the specified checker:
     <br><tt>
     $ <b>clang -cc1 -analyze -analyzer-checker=core.DivideZero test.c</b>
     </tt></li>
 
     <li>List the available checkers:
     <br><tt>
     $ <b>clang -cc1 -analyzer-checker-help</b>
     </tt></li>
 
-    <li>See the analyzer help for different output formats, fine tuning, and 
+    <li>See the analyzer help for different output formats, fine tuning, and
     debug options:
     <br><tt>
     $ <b>clang -cc1 -help | grep "analyzer"</b>
     </tt></li>
 
   </ul>
- 
 <h2 id=analyzer>Static Analyzer Overview</h2>
-  The analyzer core performs symbolic execution of the given program. All the 
-  input values are represented with symbolic values; further, the engine deduces 
-  the values of all the expressions in the program based on the input symbols  
-  and the path. The execution is path sensitive and every possible path through 
-  the program is explored. The explored execution traces are represented with 
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedGraph.html">ExplodedGraph</a> object.
-  Each node of the graph is 
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedNode.html">ExplodedNode</a>, 
+  The analyzer core performs symbolic execution of the given program. All the
+  input values are represented with symbolic values; further, the engine deduces
+  the values of all the expressions in the program based on the input symbols
+  and the path. The execution is path sensitive and every possible path through
+  the program is explored. The explored execution traces are represented with
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedGraph.html">ExplodedGraph</a> object.
+  Each node of the graph is
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedNode.html">ExplodedNode</a>,
   which consists of a <tt>ProgramPoint</tt> and a <tt>ProgramState</tt>.
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ProgramPoint.html">ProgramPoint</a> 
-  represents the corresponding location in the program (or the CFG). 
-  <tt>ProgramPoint</tt> is also used to record additional information on 
-  when/how the state was added. For example, <tt>PostPurgeDeadSymbolsKind</tt> 
-  kind means that the state is the result of purging dead symbols - the 
-  analyzer's equivalent of garbage collection. 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ProgramPoint.html">ProgramPoint</a>
+  represents the corresponding location in the program (or the CFG).
+  <tt>ProgramPoint</tt> is also used to record additional information on
+  when/how the state was added. For example, <tt>PostPurgeDeadSymbolsKind</tt>
+  kind means that the state is the result of purging dead symbols - the
+  analyzer's equivalent of garbage collection.
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ProgramState.html">ProgramState</a> 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ProgramState.html">ProgramState</a>
   represents abstract state of the program. It consists of:
   <ul>
-    <li><tt>Environment</tt> - a mapping from source code expressions to symbolic 
+    <li><tt>Environment</tt> - a mapping from source code expressions to symbolic
     values
     <li><tt>Store</tt> - a mapping from memory locations to symbolic values
     <li><tt>GenericDataMap</tt> - constraints on symbolic values
   </ul>
-  
   <h3 id=interaction>Interaction with Checkers</h3>
 
   <p>
-  Checkers are not merely passive receivers of the analyzer core changes - they 
+  Checkers are not merely passive receivers of the analyzer core changes - they
   actively participate in the <tt>ProgramState</tt> construction through the
-  <tt>GenericDataMap</tt> which can be used to store the checker-defined part 
-  of the state. Each time the analyzer engine explores a new statement, it 
-  notifies each checker registered to listen for that statement, giving it an 
-  opportunity to either report a bug or modify the state. (As a rule of thumb, 
-  the checker itself should be stateless.) The checkers are called one after another 
-  in the predefined order; thus, calling all the checkers adds a chain to the 
+  <tt>GenericDataMap</tt> which can be used to store the checker-defined part
+  of the state. Each time the analyzer engine explores a new statement, it
+  notifies each checker registered to listen for that statement, giving it an
+  opportunity to either report a bug or modify the state. (As a rule of thumb,
+  the checker itself should be stateless.) The checkers are called one after another
+  in the predefined order; thus, calling all the checkers adds a chain to the
   <tt>ExplodedGraph</tt>.
   </p>
-  
   <h3 id=values>Representing Values</h3>
 
   <p>
-  During symbolic execution, <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SVal.html">SVal</a> 
-  objects are used to represent the semantic evaluation of expressions. 
-  They can represent things like concrete 
-  integers, symbolic values, or memory locations (which are memory regions). 
-  They are a discriminated union of "values", symbolic and otherwise. 
-  If a value isn't symbolic, usually that means there is no symbolic 
-  information to track. For example, if the value was an integer, such as 
-  <tt>42</tt>, it would be a <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1nonloc_1_1ConcreteInt.html">ConcreteInt</a>, 
-  and the checker doesn't usually need to track any state with the concrete 
-  number. In some cases, <tt>SVal</tt> is not a symbol, but it really should be 
-  a symbolic value. This happens when the analyzer cannot reason about something 
-  (yet). An example is floating point numbers. In such cases, the 
-  <tt>SVal</tt> will evaluate to <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1UnknownVal.html">UnknownVal</a>.
-  This represents a case that is outside the realm of the analyzer's reasoning 
-  capabilities. <tt>SVals</tt> are value objects and their values can be viewed 
-  using the <tt>.dump()</tt> method. Often they wrap persistent objects such as 
+  During symbolic execution, <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1SVal.html">SVal</a>
+  objects are used to represent the semantic evaluation of expressions.
+  They can represent things like concrete
+  integers, symbolic values, or memory locations (which are memory regions).
+  They are a discriminated union of "values", symbolic and otherwise.
+  If a value isn't symbolic, usually that means there is no symbolic
+  information to track. For example, if the value was an integer, such as
+  <tt>42</tt>, it would be a <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1nonloc_1_1ConcreteInt.html">ConcreteInt</a>,
+  and the checker doesn't usually need to track any state with the concrete
+  number. In some cases, <tt>SVal</tt> is not a symbol, but it really should be
+  a symbolic value. This happens when the analyzer cannot reason about something
+  (yet). An example is floating point numbers. In such cases, the
+  <tt>SVal</tt> will evaluate to <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1UnknownVal.html">UnknownVal</a>.
+  This represents a case that is outside the realm of the analyzer's reasoning
+  capabilities. <tt>SVals</tt> are value objects and their values can be viewed
+  using the <tt>.dump()</tt> method. Often they wrap persistent objects such as
   symbols or regions.
   </p>
 
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymExpr.html">SymExpr</a> (symbol) 
-  is meant to represent abstract, but named, symbolic value. Symbols represent 
-  an actual (immutable) value. We might not know what its specific value is, but 
-  we can associate constraints with that value as we analyze a path. For 
-  example, we might record that the value of a symbol is greater than 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymExpr.html">SymExpr</a> (symbol)
+  is meant to represent abstract, but named, symbolic value. Symbols represent
+  an actual (immutable) value. We might not know what its specific value is, but
+  we can associate constraints with that value as we analyze a path. For
+  example, we might record that the value of a symbol is greater than
   <tt>0</tt>, etc.
   </p>
 
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1MemRegion.html">MemRegion</a> is similar to a symbol.  
-  It is used to provide a lexicon of how to describe abstract memory. Regions can 
-  layer on top of other regions, providing a layered approach to representing memory. 
-  For example, a struct object on the stack might be represented by a <tt>VarRegion</tt>, 
-  but a <tt>FieldRegion</tt> which is a subregion of the <tt>VarRegion</tt> could 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1MemRegion.html">MemRegion</a> is similar to a symbol.
+  It is used to provide a lexicon of how to describe abstract memory. Regions can
+  layer on top of other regions, providing a layered approach to representing memory.
+  For example, a struct object on the stack might be represented by a <tt>VarRegion</tt>,
+  but a <tt>FieldRegion</tt> which is a subregion of the <tt>VarRegion</tt> could
   be used to represent the memory associated with a specific field of that object.
-  So how do we represent symbolic memory regions? That's what 
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymbolicRegion.html">SymbolicRegion</a> 
-  is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the 
+  So how do we represent symbolic memory regions? That's what
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymbolicRegion.html">SymbolicRegion</a>
+  is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the
   symbol is unique and has a unique name; that symbol names the region.
   </p>
-  
   <p>
   Let's see how the analyzer processes the expressions in the following example:
   </p>
 
   <p>
   <pre class="code_example">
   int foo(int x) {
      int y = x * 2;
      int z = x;
      ...
   }
   </pre>
   </p>
 
   <p>
-Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated, 
-we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in 
-this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>. 
-Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>, 
-which references the value <b>currently bound</b> to <tt>x</tt>. That value is 
-symbolic; it's whatever <tt>x</tt> was bound to at the start of the function. 
-Let's call that symbol <tt>$0</tt>. Similarly, we evaluate the expression for <tt>2</tt>, 
-and get an <tt>SVal</tt> that references the concrete number <tt>2</tt>. When 
-we evaluate <tt>x*2</tt>, we take the two <tt>SVals</tt> of the subexpressions, 
-and create a new <tt>SVal</tt> that represents their multiplication (which in 
-this case is a new symbolic expression, which we might call <tt>$1</tt>). When we 
-evaluate the assignment to <tt>y</tt>, we again compute its lvalue (a <tt>MemRegion</tt>), 
-and then bind the <tt>SVal</tt> for the RHS (which references the symbolic value <tt>$1</tt>) 
+Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated,
+we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in
+this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>.
+Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>,
+which references the value <b>currently bound</b> to <tt>x</tt>. That value is
+symbolic; it's whatever <tt>x</tt> was bound to at the start of the function.
+Let's call that symbol <tt>$0</tt>. Similarly, we evaluate the expression for <tt>2</tt>,
+and get an <tt>SVal</tt> that references the concrete number <tt>2</tt>. When
+we evaluate <tt>x*2</tt>, we take the two <tt>SVals</tt> of the subexpressions,
+and create a new <tt>SVal</tt> that represents their multiplication (which in
+this case is a new symbolic expression, which we might call <tt>$1</tt>). When we
+evaluate the assignment to <tt>y</tt>, we again compute its lvalue (a <tt>MemRegion</tt>),
+and then bind the <tt>SVal</tt> for the RHS (which references the symbolic value <tt>$1</tt>)
 to the <tt>MemRegion</tt> in the symbolic store.
 <br>
-The second line is similar. When we evaluate <tt>x</tt> again, we do the same 
-dance, and create an <tt>SVal</tt> that references the symbol <tt>$0</tt>. Note, two <tt>SVals</tt> 
+The second line is similar. When we evaluate <tt>x</tt> again, we do the same
+dance, and create an <tt>SVal</tt> that references the symbol <tt>$0</tt>. Note, two <tt>SVals</tt>
 might reference the same underlying values.
   </p>
 
 <p>
-To summarize, MemRegions are unique names for blocks of memory. Symbols are 
-unique names for abstract symbolic values. Some MemRegions represents abstract 
-symbolic chunks of memory, and thus are also based on symbols. SVals are just 
-references to values, and can reference either MemRegions, Symbols, or concrete 
+To summarize, MemRegions are unique names for blocks of memory. Symbols are
+unique names for abstract symbolic values. Some MemRegions represents abstract
+symbolic chunks of memory, and thus are also based on symbols. SVals are just
+references to values, and can reference either MemRegions, Symbols, or concrete
 values (e.g., the number 1).
 </p>
 
-  <!-- 
+  <!--
   TODO: Add a picture.
   <br>
   Symbols<br>
-  FunctionalObjects are used throughout.  
+  FunctionalObjects are used throughout.
   -->
 
 <h2 id=idea>Idea for a Checker</h2>
-  Here are several questions which you should consider when evaluating your 
+  Here are several questions which you should consider when evaluating your
   checker idea:
   <ul>
-    <li>Can the check be effectively implemented without path-sensitive 
+    <li>Can the check be effectively implemented without path-sensitive
     analysis? See <a href="#ast">AST Visitors</a>.</li>
-    
-    <li>How high the false positive rate is going to be? Looking at the occurrences 
-    of the issue you want to write a checker for in the existing code bases might 
+    <li>How high the false positive rate is going to be? Looking at the occurrences
+    of the issue you want to write a checker for in the existing code bases might
     give you some ideas. </li>
-    
-    <li>How the current limitations of the analysis will effect the false alarm 
-    rate? Currently, the analyzer only reasons about one procedure at a time (no 
-    inter-procedural analysis). Also, it uses a simple range tracking based 
+    <li>How the current limitations of the analysis will effect the false alarm
+    rate? Currently, the analyzer only reasons about one procedure at a time (no
+    inter-procedural analysis). Also, it uses a simple range tracking based
     solver to model symbolic execution.</li>
-    
     <li>Consult the <a
-    href="http://llvm.org/bugs/buglist.cgi?query_format=advanced&amp;bug_status=NEW&amp;bug_status=REOPENED&amp;version=trunk&amp;component=Static%20Analyzer&amp;product=clang">Bugzilla database</a> 
-    to get some ideas for new checkers and consider starting with improving/fixing  
+    href="https://bugs.llvm.org/buglist.cgi?query_format=advanced&amp;bug_status=NEW&amp;bug_status=REOPENED&amp;version=trunk&amp;component=Static%20Analyzer&amp;product=clang">Bugzilla database</a>
+    to get some ideas for new checkers and consider starting with improving/fixing
     bugs in the existing checkers.</li>
   </ul>
 
 <p>Once an idea for a checker has been chosen, there are two key decisions that
 need to be made:
   <ul>
     <li> Which events the checker should be tracking. This is discussed in more
     detail in the section <a href="#events_callbacks">Events, Callbacks, and
     Checker Class Structure</a>.
     <li> What checker-specific data needs to be stored as part of the program
     state (if any). This should be minimized as much as possible. More detail about
     implementing custom program state is given in section <a
     href="#extendingstates">Custom Program States</a>.
   </ul>
 
 
 <h2 id=registration>Checker Registration</h2>
   All checker implementation files are located in
   <tt>clang/lib/StaticAnalyzer/Checkers</tt> folder. The steps below describe
-  how the checker <tt>SimpleStreamChecker</tt>, which checks for misuses of 
+  how the checker <tt>SimpleStreamChecker</tt>, which checks for misuses of
   stream APIs, was registered with the analyzer.
   Similar steps should be followed for a new checker.
 <ol>
   <li>A new checker implementation file, <tt>SimpleStreamChecker.cpp</tt>, was
   created in the directory <tt>lib/StaticAnalyzer/Checkers</tt>.
   <li>The following registration code was added to the implementation file:
 <pre class="code_example">
 void ento::registerSimpleStreamChecker(CheckerManager &amp;mgr) {

 
 After adding a new checker to the analyzer, one can verify that the new checker
 was successfully added by seeing if it appears in the list of available checkers:
 <br> <tt><b>$clang -cc1 -analyzer-checker-help</b></tt>
 
 <h2 id=events_callbacks>Events, Callbacks, and Checker Class Structure</h2>
 
 <p> All checkers inherit from the <tt><a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1Checker.html">
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Checker.html">
 Checker</a></tt> template class; the template parameter(s) describe the type of
 events that the checker is interested in processing. The various types of events
 that are available are described in the file <a
-href="http://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
+href="https://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
 CheckerDocumentation.cpp</a>
 
 <p> For each event type requested, a corresponding callback function must be
 defined in the checker class (<a
-href="http://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
+href="https://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
 CheckerDocumentation.cpp</a> shows the
 correct function name and signature for each event type).
 
 <p> As an example, consider <tt>SimpleStreamChecker</tt>. This checker needs to
 take action at the following times:
 
 <ul>
 <li>Before making a call to a function, check if the function is <tt>fclose</tt>.
 If so, check the parameter being passed.
 <li>After making a function call, check if the function is <tt>fopen</tt>. If
 so, process the return value.
 <li>When values go out of scope, check whether they are still-open file
 descriptors, and report a bug if so. In addition, remove any information about
 them from the program state in order to keep the state as small as possible.
 <li>When file pointers "escape" (are used in a way that the analyzer can no longer
 track them), mark them as such. This prevents false positives in the cases where
 the analyzer cannot be sure whether the file was closed or not.
 </ul>
 
 <p>These events that will be used for each of these actions are, respectively, <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PreCall.html">PreCall</a>,
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PreCall.html">PreCall</a>,
 <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PostCall.html">PostCall</a>,
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PostCall.html">PostCall</a>,
 <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1DeadSymbols.html">DeadSymbols</a>,
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1DeadSymbols.html">DeadSymbols</a>,
 and <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PointerEscape.html">PointerEscape</a>.
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PointerEscape.html">PointerEscape</a>.
 The high-level structure of the checker's class is thus:
 
 <pre class="code_example">
 class SimpleStreamChecker : public Checker&lt;check::PreCall,
                                            check::PostCall,
                                            check::DeadSymbols,
                                            check::PointerEscape&gt; {
 public:

 program will be explored, or even that all possible paths will be explored, this
 state information cannot be kept within individual checkers. Therefore, if
 checkers need to store custom information, they need to add new categories of
 data to the <tt>ProgramState</tt>. The preferred way to do so is to use one of
 several macros designed for this purpose. They are:
 
 <ul>
 <li><a
-href="http://clang.llvm.org/doxygen/ProgramStateTrait_8h.html#ae4cddb54383cd702a045d7c61b009147">REGISTER_TRAIT_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/ProgramStateTrait_8h.html#ae4cddb54383cd702a045d7c61b009147">REGISTER_TRAIT_WITH_PROGRAMSTATE</a>:
 Used when the state information is a single value. The methods available for
 state types declared with this macro are <tt>get</tt>, <tt>set</tt>, and
 <tt>remove</tt>.
 <li><a
-href="http://clang.llvm.org/doxygen/CheckerContext_8h.html#aa27656fa0ce65b0d9ba12eb3c02e8be9">REGISTER_LIST_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/CheckerContext_8h.html#aa27656fa0ce65b0d9ba12eb3c02e8be9">REGISTER_LIST_WITH_PROGRAMSTATE</a>:
 Used when the state information is a list of values. The methods available for
 state types declared with this macro are <tt>add</tt>, <tt>get</tt>,
 <tt>remove</tt>, and <tt>contains</tt>.
 <li><a
-href="http://clang.llvm.org/doxygen/CheckerContext_8h.html#ad90f9387b94b344eaaf499afec05f4d1">REGISTER_SET_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/CheckerContext_8h.html#ad90f9387b94b344eaaf499afec05f4d1">REGISTER_SET_WITH_PROGRAMSTATE</a>:
 Used when the state information is a set of values. The methods available for
 state types declared with this macro are <tt>add</tt>, <tt>get</tt>,
 <tt>remove</tt>, and <tt>contains</tt>.
 <li><a
-href="http://clang.llvm.org/doxygen/CheckerContext_8h.html#a6d1893bb8c18543337b6c363c1319fcf">REGISTER_MAP_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/CheckerContext_8h.html#a6d1893bb8c18543337b6c363c1319fcf">REGISTER_MAP_WITH_PROGRAMSTATE</a>:
 Used when the state information is a map from a key to a value. The methods
 available for state types declared with this macro are <tt>add</tt>,
 <tt>set</tt>, <tt>get</tt>, <tt>remove</tt>, and <tt>contains</tt>.
 </ul>
 
 <p>All of these macros take as parameters the name to be used for the custom
 category of state information and the data type(s) to be used for storage. The
 data type(s) specified will become the parameter type and/or return type of the

 ProgramStateRef newState = state-&gt;set&lt;ExampleDataType&gt;(Sym, newValue);
 </pre>
 
 <p>In addition, the macros define a data type used for storing the data of the
 new data category; the name of this type is the name of the data category with
 "Ty" appended. For <tt>REGISTER_TRAIT_WITH_PROGRAMSTATE</tt>, this will simply
 be passed data type; for the other three macros, this will be a specialized
 version of the <a
-href="http://llvm.org/doxygen/classllvm_1_1ImmutableList.html">llvm::ImmutableList</a>,
+href="https://llvm.org/doxygen/classllvm_1_1ImmutableList.html">llvm::ImmutableList</a>,
 <a
-href="http://llvm.org/doxygen/classllvm_1_1ImmutableSet.html">llvm::ImmutableSet</a>,
+href="https://llvm.org/doxygen/classllvm_1_1ImmutableSet.html">llvm::ImmutableSet</a>,
 or <a
-href="http://llvm.org/doxygen/classllvm_1_1ImmutableMap.html">llvm::ImmutableMap</a>
+href="https://llvm.org/doxygen/classllvm_1_1ImmutableMap.html">llvm::ImmutableMap</a>
 templated class. For the <tt>ExampleDataType</tt> example above, the type
 created would be equivalent to writing the declaration:
 
 <pre class="code_example">
 typedef llvm::ImmutableMap&lt;SymbolRef, int&gt; ExampleDataTypeTy;
 </pre>
 
 <p>These macros will cover a majority of use cases; however, they still have a
 few limitations. They cannot be used inside namespaces (since they expand to
 contain top-level namespace references), and the data types that they define
 cannot be referenced from more than one file.
 
 <p>Note that <tt>ProgramStates</tt> are immutable; instead of modifying an existing
 one, functions that modify the state will return a copy of the previous state
 with the change applied. This updated state must be then provided to the
 analyzer core by calling the <tt>CheckerContext::addTransition</tt> function.
 <h2 id=bugs>Bug Reports</h2>
 
 
 <p> When a checker detects a mistake in the analyzed code, it needs a way to
 report it to the analyzer core so that it can be displayed. The two classes used
 to construct this report are <tt><a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugType.html">BugType</a></tt>
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugType.html">BugType</a></tt>
 and <tt><a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugReport.html">
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugReport.html">
 BugReport</a></tt>.
 
 <p>
 <tt>BugType</tt>, as the name would suggest, represents a type of bug. The
 constructor for <tt>BugType</tt> takes two parameters: The name of the bug
 type, and the name of the category of the bug. These are used (e.g.) in the
 summary page generated by the scan-build tool.
 

 <p>In order to obtain the correct <tt>ExplodedNode</tt>, a decision must be made
 as to whether or not analysis can continue along the current path. This decision
 is based on whether the detected bug is one that would prevent the program under
 analysis from continuing. For example, leaking of a resource should not stop
 analysis, as the program can continue to run after the leak. Dereferencing a
 null pointer, on the other hand, should stop analysis, as there is no way for
 the program to meaningfully continue after such an error.
 
-<p>If analysis can continue, then the most recent <tt>ExplodedNode</tt> 
-generated by the checker can be passed to the <tt>BugReport</tt> constructor 
-without additional modification. This <tt>ExplodedNode</tt> will be the one 
+<p>If analysis can continue, then the most recent <tt>ExplodedNode</tt>
+generated by the checker can be passed to the <tt>BugReport</tt> constructor
+without additional modification. This <tt>ExplodedNode</tt> will be the one
 returned by the most recent call to <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition</a>.
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition</a>.
 If no transition has been performed during the current callback, the checker should call <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition()</a> 
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition()</a>
 and use the returned node for bug reporting.
 
 <p>If analysis can not continue, then the current state should be transitioned
 into a so-called <i>sink node</i>, a node from which no further analysis will be
 performed. This is done by calling the <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#adeea33a5a2bed190210c4a2bb807a6f0">
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#adeea33a5a2bed190210c4a2bb807a6f0">
 CheckerContext::generateSink</a> function; this function is the same as the
 <tt>addTransition</tt> function, but marks the state as a sink node. Like
 <tt>addTransition</tt>, this returns an <tt>ExplodedNode</tt> with the updated
 state, which can then be passed to the <tt>BugReport</tt> constructor.
 
 <p>
-After a <tt>BugReport</tt> is created, it should be passed to the analyzer core 
-by calling <a href = "http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#ae7738af2cbfd1d713edec33d3203dff5">CheckerContext::emitReport</a>.
+After a <tt>BugReport</tt> is created, it should be passed to the analyzer core
+by calling <a href = "https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#ae7738af2cbfd1d713edec33d3203dff5">CheckerContext::emitReport</a>.
 
 <h2 id=ast>AST Visitors</h2>
-  Some checks might not require path-sensitivity to be effective. Simple AST walk 
-  might be sufficient. If that is the case, consider implementing a Clang 
-  compiler warning. On the other hand, a check might not be acceptable as a compiler 
-  warning; for example, because of a relatively high false positive rate. In this 
-  situation, AST callbacks <tt><b>checkASTDecl</b></tt> and 
-  <tt><b>checkASTCodeBody</b></tt> are your best friends. 
+  Some checks might not require path-sensitivity to be effective. Simple AST walk
+  might be sufficient. If that is the case, consider implementing a Clang
+  compiler warning. On the other hand, a check might not be acceptable as a compiler
+  warning; for example, because of a relatively high false positive rate. In this
+  situation, AST callbacks <tt><b>checkASTDecl</b></tt> and
+  <tt><b>checkASTCodeBody</b></tt> are your best friends.
 
 <h2 id=testing>Testing</h2>
-  Every patch should be well tested with Clang regression tests. The checker tests 
-  live in <tt>clang/test/Analysis</tt> folder. To run all of the analyzer tests, 
+  Every patch should be well tested with Clang regression tests. The checker tests
+  live in <tt>clang/test/Analysis</tt> folder. To run all of the analyzer tests,
   execute the following from the <tt>clang</tt> build directory:
     <pre class="code">
     $ <b>bin/llvm-lit -sv ../llvm/tools/clang/test/Analysis</b>
     </pre>
 
 <h2 id=commands>Useful Commands/Debugging Hints</h2>
 
 <h3 id=attaching>Attaching the Debugger</h3>

 Programs.</a></li>
 <li><a href="https://github.com/llvm/llvm-project/blob/master/clang/lib/StaticAnalyzer/README.txt">
 The Clang Static Analyzer README</a></li>
 <li><a href="https://github.com/llvm/llvm-project/blob/master/clang/docs/analyzer/RegionStore.txt">
 Documentation for how the Store works</a></li>
 <li><a href="https://github.com/llvm/llvm-project/blob/master/clang/docs/analyzer/IPA.txt">
 Documentation about inlining</a></li>
 <li> The "Building a Checker in 24 hours" presentation given at the <a
-href="http://llvm.org/devmtg/2012-11">November 2012 LLVM Developer's
+href="https://llvm.org/devmtg/2012-11">November 2012 LLVM Developer's
 meeting</a>. Describes the construction of SimpleStreamChecker. <a
-href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
+href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
 and <a
 href="https://youtu.be/kdxlsP5QVPw">video</a>
 are available.</li>
 <li>
 <a href="https://github.com/haoNoQ/clang-analyzer-guide/releases/download/v0.1/clang-analyzer-guide-v0.1.pdf">
 Artem Degrachev: Clang Static Analyzer: A Checker Developer's Guide
 </a> (reading the previous items first might be a good idea)</li>
 <li>The list of <a href="implicit_checks.html">Implicit Checkers</a></li>
-<li> <a href="http://clang.llvm.org/doxygen">Clang doxygen</a>. Contains
+<li> <a href="https://clang.llvm.org/doxygen">Clang doxygen</a>. Contains
 up-to-date documentation about the APIs available in Clang. Relevant entries
 have been linked throughout this page. Also of use is the
-<a href="http://llvm.org/doxygen">LLVM doxygen</a>, when dealing with classes
+<a href="https://llvm.org/doxygen">LLVM doxygen</a>, when dealing with classes
 from LLVM.</li>
-<li> The <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">
+<li> The <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">
 cfe-dev mailing list</a>. This is the primary mailing list used for
 discussion of Clang development (including static code analysis). The
-<a href="http://lists.llvm.org/pipermail/cfe-dev">archive</a> also contains
+<a href="https://lists.llvm.org/pipermail/cfe-dev">archive</a> also contains
 a lot of information.</li>
 </ul>
 
 </div>
 </div>
 </body>
 </html>

clang/www/analyzer/faq.html

 </pre>
 Note that this cast does not affect code generation.
 </p>
 
 <h4 id="use_assert" class="faq">Q: The analyzer assumes that a loop body is never entered.  How can I tell it that the loop body will be entered at least once?</h4>
 
 <img src="images/example_use_assert.png" alt="example use assert">
 
-<p> In the contrived example above, the analyzer has detected that the body of 
-the loop is never entered for the case where <tt>length <= 0</tt>. In this 
-particular example, you may know that the loop will always be entered because 
-the input parameter <tt>length</tt> will be greater than zero in all calls to this 
-function. You can teach the analyzer facts about your code as well as document 
-it by using assertions. By adding <tt>assert(length > 0)</tt> in the beginning 
-of the function, you tell the analyzer that your code is never expecting a zero 
+<p> In the contrived example above, the analyzer has detected that the body of
+the loop is never entered for the case where <tt>length <= 0</tt>. In this
+particular example, you may know that the loop will always be entered because
+the input parameter <tt>length</tt> will be greater than zero in all calls to this
+function. You can teach the analyzer facts about your code as well as document
+it by using assertions. By adding <tt>assert(length > 0)</tt> in the beginning
+of the function, you tell the analyzer that your code is never expecting a zero
 or a negative value, so it won't need to test the correctness of those paths.
 </p>
 
 <pre class="code_example">
 int foo(int length) {
   int x = 0;
   <span class="code_highlight">assert(length > 0);</span>
   for (int i = 0; i < length; i++)
     x += 1;
   return length/x;
 }
 </pre>
 
 <h4 id="suppress_issue" class="faq">Q: How can I suppress a specific analyzer warning?</h4>
 
 <p>There is currently no solid mechanism for suppressing an analyzer warning,
 although this is currently being investigated. When you encounter an analyzer
 bug/false positive, check if it's one of the issues discussed above or if the
-analyzer <a href = "annotations.html#custom_assertions" >annotations</a> can 
-resolve the issue. Second, please <a href = "filing_bugs.html">report it</a> to 
+analyzer <a href = "annotations.html#custom_assertions" >annotations</a> can
+resolve the issue. Second, please <a href = "filing_bugs.html">report it</a> to
 help us improve user experience. As the last resort, consider using <tt>__clang_analyzer__</tt> macro
 <a href = "faq.html#exclude_code" >described below</a>.</p>
 
 <h4 id="exclude_code" class="faq">Q: How can I selectively exclude code the analyzer examines?</h4>
 
-<p>When the static analyzer is using clang to parse source files, it implicitly 
-defines the preprocessor macro <tt>__clang_analyzer__</tt>. One can use this 
+<p>When the static analyzer is using clang to parse source files, it implicitly
+defines the preprocessor macro <tt>__clang_analyzer__</tt>. One can use this
 macro to selectively exclude code the analyzer examines. Here is an example:
 
 <pre class="code_example">
 #ifndef __clang_analyzer__
 // Code not to be analyzed
 #endif
 </pre>
 
-This usage is discouraged because it makes the code dead to the analyzer from 
-now on. Instead, we prefer that users file bugs against the analyzer when it flags 
+This usage is discouraged because it makes the code dead to the analyzer from
+now on. Instead, we prefer that users file bugs against the analyzer when it flags
 false positives.
 </p>
 
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/filing_bugs.html

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <html>
 <head>
   <title>Filing Bugs and Feature Requests</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
 </head>
 <body>
 
 <div id="page">
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
 
 <h1>Filing Bugs and Feature Requests</h1>
 
 <p>We encourage users to file bug reports for any problems that they encounter.
 We also welcome feature requests. When filing a bug report, please do the
 following:</p>
 
-<ul>  
+<ul>
 
 <li>Include the checker build (for prebuilt Mac OS X binaries) or the SVN
 revision number.</li>
 
 <li>Provide a self-contained, reduced test case that exhibits the issue you are
 experiencing.</li>
 
 <li>Test cases don't tell us everything. Please briefly describe the problem you
 are seeing, including what you thought should have been the expected behavior
 and why.</li>
 
 </ul>
 
 <h2>Outside of Apple</h2>
 
 <h3>Bugzilla</h3>
 
-<p>Please <a href="http://llvm.org/bugs/enter_bug.cgi?product=clang">file
+<p>Please <a href="https://bugs.llvm.org/enter_bug.cgi?product=clang">file
 bugs</a> in LLVM's Bugzilla database against the Clang <b>Static Analyzer</b>
 component.</p>
 
 <h3>Bugreporter.apple.com</h3>
 
 <p>If you are using the analyzer to analyze code associated with an Apple NDA
 (e.g., preview versions of SDKs or seed releases of Mac OS X) please file bug
-reports to Apple's <a href="http://bugreporter.apple.com">Bug Reporter</a> web
+reports to Apple's <a href="https://feedbackassistant.apple.com/welcome">Feedback Assistant</a> web
 site.</p>
 
 <p>You are free to always file bugs through this website, but this option is less
 attractive than filing bug reports through Bugzilla as not everyone who works on
 the analyzer has access to that bug database.</p>
 
 <h2>Apple-internal Users</h2>
 
 <p>Please file bugs in Radar against the <b>clang - static analyzer</b> component.</p>
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/implicit_checks.html

 </head>
 <body onload="initExpandCollapse()">
 
 <div id="page">
 <!--#include virtual="menu.html.incl"-->
 
 <div id="content">
 <h1>Implicit Checkers</h1>
-Even though the implicit checkers do not produce any warnings, they are used to 
-support the analyzer core and model known APIs. See also 
+Even though the implicit checkers do not produce any warnings, they are used to
+support the analyzer core and model known APIs. See also
 <a href = "available_checks.html">Default Checkers</a>
 and <a href = "alpha_checks.html">Experimental (Alpha) Checkers</a>.
 <ul>
 <li><a href="#core_implicit_checkers">Core Implicit Checkers</a></li>
 <li><a href="#osx_implicit_checkers">OS X Implicit Checkers</a></li>
 </ul>
 
 <!-- =========================== core implicit =========================== -->

 public:
   A(int x) {}
   virtual int foo();
 };
 
 class B: public A {
 public:
   B()
-  :A(foo()) 
+  :A(foo())
   // DynamicTypeInfo for 'this' rigion will wrap type 'A'
   // unless the base constructor call expression is processed
-  {} 
+  {}
   virtual int foo();
 };
 </pre></div><div class="separator"></div>
 <div class="example"><pre>
 // Objective-C
 @interface MyClass : NSObject {}
 @end
 

 <div class="example"><pre>
 // Objective-C
 @interface MyObj : NSObject {}
 - (void)foo;
 @end
 
 @implementation MyObj
 - (void)foo {
-  [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd 
-                                       object:self 
-                                       file:(@"somefile.m") 
-                                       lineNumber:1 
+  [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd
+                                       object:self
+                                       file:(@"somefile.m")
+                                       lineNumber:1
                                        description:(@"some text")];
     // generate sink
 }
 @end
 </pre></div></div></td></tr>
 
 </tbody></table>
 
 <!-- =========================== OS X implicit =========================== -->
 <h3 id="osx_implicit_checkers">OS X Implicit Checkers</h3>
 <table class="checkers">
 <colgroup><col class="namedescr"><col class="example"></colgroup>
 <thead><tr><td>Name, Description</td><td>Example</td></tr></thead>
 
 <tbody>
 <tr><td><div class="namedescr expandable"><span class="name">
 osx.cocoa.Loops</span><span class="lang">
 (ObjC)</span><div class="descr">
 Improved modeling of loops using Cocoa collection types.</div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void test() {
   id x;
-  for (x in [NSArray testObject]) { 
+  for (x in [NSArray testObject]) {
     // assume the value of 'x' is non-nil
   }
 }
 </pre></div></div></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 osx.cocoa.NonNilReturnValue</span><span class="lang">

clang/www/analyzer/index.html

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <html>
 <head>
   <title>Clang Static Analyzer</title>
   <link type="text/css" rel="stylesheet" href="content.css">
   <link type="text/css" rel="stylesheet" href="menu.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
   <!-- Generated from: http://www.spiffycorners.com/index.php -->
 
 <style type="text/css">
 .spiffy{display:block}
 .spiffy *{
   display:block;
   height:1px;
   overflow:hidden;

 .spiffy4{
   border-left:1px solid #f6f8fc;
   border-right:1px solid #f6f8fc}
 .spiffy5{
   border-left:1px solid #f0f3fb;
   border-right:1px solid #f0f3fb}
 .spiffyfg{
   background:#EBF0FA}
-  
 .spiffyfg h2 {
   margin:0px;  padding:10px;
 }
 
   #left { float:left; }
   #left h2 { margin:1px; padding-top:0px; }
   #right { float:left; margin-left:20px; margin-right:20px; padding:0px ;}
   #right h2 { padding:0px; margin:0px; }
   #wrappedcontent { padding:15px;}
 </style>
 </head>
 <body>
 
 <div id="page">
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
 
 
 <table style="margin-top:0px" width="100%" border="0" cellpadding="0px" cellspacing="0">
 <tr><td>
 
-<h1>Clang Static Analyzer</h1>  
+<h1>Clang Static Analyzer</h1>
 
 <p>The Clang Static Analyzer is a source code analysis tool that finds bugs in
 C, C++, and Objective-C programs.</p>
 
 <p>Currently it can be run either as a <a href="scan-build.html">standalone
 tool</a> or <a href="xcode.html">within Xcode</a>. The standalone tool is
 invoked from the command line, and is intended to be run in tandem with a build
 of a codebase.</p>
 
 <p>The analyzer is 100% open source and is part of the <a
-href="http://clang.llvm.org">Clang</a> project. Like the rest of Clang, the
+href="https://clang.llvm.org">Clang</a> project. Like the rest of Clang, the
 analyzer is implemented as a C++ library that can be used by other tools and
 applications.</p>
 
 <h2>Download</h2>
 
 <div style="padding:0px; font-size: 90%">
  <b class="spiffy">
  <b class="spiffy1"><b></b></b>

  <b class="spiffy">
  <b class="spiffy1"><b></b></b>
  <b class="spiffy2"><b></b></b>
  <b class="spiffy3"></b>
  <b class="spiffy4"></b>
  <b class="spiffy5"></b></b>
  <div class="spiffyfg">
   <div style="padding:15px">
-   <h3 style="margin:0px;padding:0px">Other Platforms</h3>    
+   <h3 style="margin:0px;padding:0px">Other Platforms</h3>
    <p>For other platforms, please follow the instructions for <a
    href="/installation#OtherPlatforms">building the analyzer</a> from
    source code.<p>
   </div>
  </div>
  <b class="spiffy">
  <b class="spiffy5"></b>
  <b class="spiffy4"></b>

 to automatically find bugs. The idea is similar in spirit to compiler warnings
 (which can be useful for finding coding errors) but to take that idea a step
 further and find bugs that are traditionally found using run-time debugging
 techniques such as testing.</p>
 
 <p>Static analysis bug-finding tools have evolved over the last several decades
 from basic syntactic checkers to those that find deep bugs by reasoning about
 the semantics of code. The goal of the Clang Static Analyzer is to provide a
-industrial-quality static analysis framework for analyzing C, C++, and 
+industrial-quality static analysis framework for analyzing C, C++, and
 Objective-C programs that is freely available, extensible, and has a high quality of implementation.</p>
 
 <h3 id="Clang">Part of Clang and LLVM</h3>
 
 <p>As its name implies, the Clang Static Analyzer is built on top of <a
-href="http://clang.llvm.org">Clang</a> and <a href="http://llvm.org">LLVM</a>.
+href="https://clang.llvm.org">Clang</a> and <a href="https://llvm.org">LLVM</a>.
 Strictly speaking, the analyzer is part of Clang, as Clang consists of a set of
 reusable C++ libraries for building powerful source-level tools. The static
 analysis engine used by the Clang Static Analyzer is a Clang library, and has
 the capability to be reused in different contexts and by different clients.</p>
 
 <h2>Important Points to Consider</h2>
 
 <p>While we believe that the static analyzer is already very useful for finding

 you would like the Clang Static Analyzer to find, please feel free to
 file <a href="filing_bugs.html">feature requests</a> or contribute your own
 patches.</p>
 
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/installation.html

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <html>
 <head>
   <title>Obtaining the Static Analyzer</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
 </head>
 <body>
 
 <div id="page">
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
 
 <h1>Obtaining the Static Analyzer</h1>

 OS X.  These are built to run on OS X 10.7 and later.</p>
 
 <p>Builds are released frequently.  Often the differences between build
 numbers being a few bug fixes or minor feature improvements.  When using
 the analyzer, we recommend that you check back here occasionally for new
 builds, especially if the build you are using is more than a couple
 weeks old.</p>
 
-<p>The latest build is: 
+<p>The latest build is:
   <!--#include virtual="latest_checker.html.incl"-->
 </p>
 
 <p>Packaged builds for other platforms may eventually be provided, but
 we need volunteers who are willing to help provide such regular builds.
 If you wish to help contribute regular builds of the analyzer on other
 platforms, please email the <a
-href="http://lists.llvm.org/mailman/listinfo/cfe-dev">Clang
+href="https://lists.llvm.org/mailman/listinfo/cfe-dev">Clang
 Developers' mailing list</a>.</p>
 
 <h3>Using Packaged Builds</h3>
 
 <p>To use a package build, simply unpack it anywhere.  If the build
 archive has the name <b><tt>checker-XXX.tar.bz2</tt></b> then the
 archive will expand to a directory called <b><tt>checker-XXX</tt></b>.
 You do not need to place this directory or the contents of this

 a symbolic link to <tt>scan-build</tt>, such one located in a directory
 in your path. When <tt>scan-build</tt> runs it will automatically
 determine where to find its accompanying files.</p>
 
 <h2 id="OtherPlatforms">Other Platforms (Building the Analyzer from Source)</h2>
 
 <p>For other platforms, you must build Clang and LLVM manually.  To do
 so, please follow the instructions for <a
-href="http://clang.llvm.org/get_started.html#build">building Clang from
+href="https://clang.llvm.org/get_started.html#build">building Clang from
 source code</a>.<p>
 
 <p>Once the Clang is built, you need to add the following to your path:</p>
 
 <ul>
 
 <li>The location of the <tt>clang</tt> binary.
 

 <p>These are installed via <tt>make install</tt> into the bin directory
 when clang is built.</p></li>
 
 </ul>
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/open_projects.html

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <html>
 <head>
   <title>Open Projects</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
 </head>
 <body>
 
 <div id="page">
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
 
 <h1>Open Projects</h1>
 
-<p>This page lists several projects that would boost analyzer's usability and 
-power. Most of the projects listed here are infrastructure-related so this list 
-is an addition to the <a href="potential_checkers.html">potential checkers 
-list</a>. If you are interested in tackling one of these, please send an email 
-to the <a href=http://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev
+<p>This page lists several projects that would boost analyzer's usability and
+power. Most of the projects listed here are infrastructure-related so this list
+is an addition to the <a href="potential_checkers.html">potential checkers
+list</a>. If you are interested in tackling one of these, please send an email
+to the <a href=https://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev
 mailing list</a> to notify other members of the community.</p>
 
 <ul>
   <li>Release checkers from "alpha"
     <p>New checkers which were contributed to the analyzer,
     but have not passed a rigorous evaluation process,
     are committed as "alpha checkers" (from "alpha version"),
     and are not enabled by default.</p>
<ul>
       without a proper
       <a href="https://en.wikipedia.org/wiki/Widening_(computer_science)">loop widening</a> support.
       Additionally, it might be more promising to perform index checking based on
       <a href="https://en.wikipedia.org/wiki/Taint_checking">tainted</a> index values.
       <p><i>(Difficulty: Medium)</i></p></p>
       </li>
 
       <li><code>alpha.unix.StreamChecker</code>
-        <p>A SimpleStreamChecker has been presented in the Building a Checker in 24 
-        Hours talk 
-        (<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
+        <p>A SimpleStreamChecker has been presented in the Building a Checker in 24
+        Hours talk
+        (<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
         <a href="https://youtu.be/kdxlsP5QVPw">video</a>).</p>
 
         <p>This alpha checker is an attempt to write a production grade stream checker.
         However, it was found to have an unacceptably high false positive rate.
         One of the found problems was that eagerly splitting the state
         based on whether the system call may fail leads to too many reports.
         A <em>delayed</em> split where the implication is stored in the state
         (similarly to nullability implications in <code>TrustNonnullChecker</code>)
<ul>
 
     <li>Handle constructors of lambda captures
       <p>Variables which are captured by value into a lambda require a call to
          a copy constructor.
          This call is not currently modeled.
       </p>
     </li>
 
-    <li>Handle constructors for default arguments 
+    <li>Handle constructors for default arguments
       <p>Default arguments in C++ are recomputed at every call,
          and are therefore local, and not static, variables.
       </p>
     </li>
 
     <li>Enhance the modeling of the standard library.
       <p>The analyzer needs a better understanding of STL in order to be more
       useful on C++ codebases.
<ul>
   </li>
 
   <li>Core Analyzer Infrastructure
   <ul>
     <li>Handle unions.
       <p>Currently in the analyzer the value of a union is always regarded as
       an unknown.
       This problem was
-      previously <a href="http://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">discussed</a>
+      previously <a href="https://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">discussed</a>
       on the mailing list, but no solution was implemented.
       <p><i> (Difficulty: Medium) </i></p></p>
     </li>
 
     <li>Floating-point support.
       <p>Currently, the analyzer treats all floating-point values as unknown.
       This project would involve adding a new <code>SVal</code> kind
       for constant floats, generalizing the constraint manager to handle floats,
<ul>
   </li>
 
 </ul>
 
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/potential_checkers.html

 <table class="checkers">
 <col class="namedescr"><col class="example"><col class="progress">
 <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead>
 
 <tr><td><div class="namedescr expandable"><span class="name">
 memory.LeakEvalOrder</span><span class="lang">
 (C, C++)</span><div class="descr">
 Potential memory leaks caused by an undefined argument evaluation order.
-<p>Source: <a href="http://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm#BestPractices">
+<p>Source: <a href="https://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm#BestPractices">
 boost docs: shared_ptr</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void f(int, int);
 int g(void *);
 int h() __attribute__((noreturn));
 
 void test() {

 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 memory.NegativeArraySize</span><span class="lang">
 (C, C++)</span><div class="descr">
 'n' is used to specify the buffer size may be negative.
 <br>Note: possibly an enhancement to <span class="name">
 alpha.security.MallocOverflow</span>.
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/20.html">CWE-20,
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/20.html">CWE-20,
 Example 2</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void test() {
   int *p;
   int n1 = -1;
   p = new int[n1]; // warn
 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 <tr><td><div class="namedescr expandable"><span class="name">
 memory.ZeroAlloc</span><span class="lang">
 (C, C++)</span><div class="descr">
 Allocation of zero bytes.
 <br>Note: an enhancement to <span class="name">unix.Malloc</span>.
-<br>Note: <span class="name">unix.API</span> perform C-checks for zero 
+<br>Note: <span class="name">unix.API</span> perform C-checks for zero
 allocation. This should be moved to <span class="name">unix.Malloc</span>.
 <p>Source: C++03 3.7.3.1p2; C++11 3.7.4.1p2.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;stdlib.h&gt;
 
 void test() {
   int *p = malloc(0); // warn
   free(p);
 }
 </pre></div>
 <div class="example"><pre>
 void test() {
   int *p = new int[0]; // warn
   delete[] p;
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://reviews.llvm.org/D6178">
+<td class="aligned"><a href="https://reviews.llvm.org/D6178">
 D6178</a></td></tr>
 
 </table>
 
 <!-- ======================= constructors/destructors ====================== -->
 <h3>constructors/destructors</h3>
 <table class="checkers">
 <col class="namedescr"><col class="example"><col class="progress">
int test(bool cond) {
   int i = 0;
   if (cond) {
     const int delta = computeDelta();
     // warn: forgot to modify 'i'
   }
   return i;
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16890">PR16890</a></td></tr>
+<td class="aligned"><a href="https://bugs.llvm.org/show_bug.cgi?id=16890">PR16890</a></td></tr>
 
 <tr><td><div class="namedescr expandable"><span class="name">
 deadcode.IdempotentOperations</span><span class="lang">
 (C)</span><div class="descr">
 Warn about idempotent operations.</div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void test() {

 }
 
 void use(int fd) {
   int count;
   if (!readWrapper(fd, &amp;count))
     print("%d", count); // should not warn
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=18701">PR18701</a></td></tr>
+<td class="aligned"><a href="https://bugs.llvm.org/show_bug.cgi?id=18701">PR18701</a></td></tr>
 
 </table>
 
 <!-- ========================= undefined behavior ========================== -->
 <h3>undefined behavior</h3>
 <table class="checkers">
 <col class="namedescr"><col class="example"><col class="progress">
 <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead>

 };
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.LocalStaticDestroyed</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: function containing a definition of static local object is 
-called during the destruction of an object with static storage duration so that 
-flow of control passes through the definition of the previously destroyed 
+Undefined behavior: function containing a definition of static local object is
+called during the destruction of an object with static storage duration so that
+flow of control passes through the definition of the previously destroyed
 static local object.
 <p>Source: C++11 3.6.3p2.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void f();
 
 class A {
 public:

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ZeroAllocDereference</span><span class="lang">
 (C, C++)</span><div class="descr">
-The effect of dereferencing a pointer returned as a request for zero size is 
+The effect of dereferencing a pointer returned as a request for zero size is
 undefined.<br>
 Note: possibly an enhancement to <span class="name">
 unix.Malloc</span>.
 <p>Source: C++03 3.7.3.1p2; C++11 3.7.4.1p2.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;stdlib.h&gt;
 
 void test() {
   int *p = (int *)malloc(0);
   *p = 1; // warn
   free(p);
 }
 </pre></div>
 <div class="example"><pre>
 void f(int);
 
 void test() {
   int *p = new int[0];
   f(*p); // warn
   delete[] p;
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://reviews.llvm.org/D8273">D8273</a></td></tr>
+<td class="aligned"><a href="https://reviews.llvm.org/D8273">D8273</a></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.DeadReferenced</span><span class="lang">
 (C++)</span><div class="descr">
 Undefined behavior: the following usage of the pointer to the object whose
 lifetime has ended can result in undefined behavior:<br>
 The object will be or was of a class type with a non-trivial destructor and
 <ul><li>the pointer is used as the operand of a delete-expression</li></ul>
 The object will be or was of a non-POD class type (C++11: any class type) and
 <ul><li>the pointer is used to access a non-static data member or call a
 non-static member function of the object</li>
 <li>the pointer is implicitly converted to a pointer to a base class
 type</li>
 <li>the pointer is used as the operand of a <code>static_cast</code> (except
-when the conversion is to <code>void*</code>, or to <code>void*</code> and 
+when the conversion is to <code>void*</code>, or to <code>void*</code> and
 subsequently to <code>char*</code>, or <code>unsigned char*</code>)</li>
 <li>the pointer is used as the operand of a <code>dynamic_cast</code></li></ul>
 <p>Source: C++03 3.8p5, p7; C++11 3.8p5, p7.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;new&gt;
 
 class A {

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ObjLocChanges</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: the program must ensure that an object occupies the same 
+Undefined behavior: the program must ensure that an object occupies the same
 storage location when the implicit or explicit destructor call takes place.
 <p>Source: C++11 3.8p8.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;new&gt;
 
 class A {};
 

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ExprEvalOrderUndef</span><span class="lang">
 (C, C++03)</span><div class="descr">
-Undefined behavior: a scalar object shall have its stored value modified at 
+Undefined behavior: a scalar object shall have its stored value modified at
 most once by the evaluation of an expression.<br>
 Note: most cases are currently handled by the Clang core (search for 'multiple
 unsequenced modifications' warning in Clang tests).
 <p>Source: C++03 5p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 int test () {
   int i = 0;
   i = ++i + 1; // warn
   return i;
 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.StaticInitReentered</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: static declaration is re-entered while the object is being 
+Undefined behavior: static declaration is re-entered while the object is being
 initialized.
 <p>Source: C++11 6.7p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 int test(int i) {
   static int s = test(2 * i); // warn
   return i + 1;
 }

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.DeadDestructed</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: the destructor is invoked for an object whose lifetime 
+Undefined behavior: the destructor is invoked for an object whose lifetime
 has ended.
 <p>Source: C++11 12.4p14.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 class A {
 public:
   void f();
   A();

 };
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.MemberOrBaseRefBeforeCtor</span><span class="lang">
 (C++)</span><div class="descr">
-C++ Undefined behavior: non-static member or base class of non-POD class type 
+C++ Undefined behavior: non-static member or base class of non-POD class type
 is referred before constructor begins execution.<br>
-C++11 Undefined behavior: non-static member or base class of a class with a 
+C++11 Undefined behavior: non-static member or base class of a class with a
 non-trivial constructor is referred before constructor begins execution.
 <p>Source: C++03 12.7p1; C++11 12.7p1.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 struct non_POD {
   int i;
   non_POD();
 };
 
 extern non_POD non_pod;
 
 int *p = &amp;non_pod.i; // warn
 </pre></div>
 <div class="example"><pre>
-struct POD { 
-  int i; 
+struct POD {
+  int i;
 };
 
 struct non_POD : public POD {
   POD pod;
 };
 
 extern non_POD non_pod;
 
 int *p = &amp;non_pod.pod.i; // warn
 </pre></div>
 <div class="example"><pre>
 struct POD {
-  int i; 
+  int i;
 };
 
 struct non_POD : public POD {};
 
 extern non_POD non_pod;
 
 POD *p = &amp;non_pod; // warn
 </pre></div>

 };
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.MemberRefAfterDtor</span><span class="lang">
 (C++)</span><div class="descr">
-C++03: Undefined behavior: non-static member of non-POD class type is referred 
+C++03: Undefined behavior: non-static member of non-POD class type is referred
 after destructor ends execution.<br>
-C++11: Undefined behavior: non-static member of a class with a non-trivial 
+C++11: Undefined behavior: non-static member of a class with a non-trivial
 destructor is referred after destructor ends execution.
 <p>Source: C++03 12.7p1; C++11 12.7p1.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 class C {
 public:
   C();
   void f();
 };
 
 void test() {
   C *c = new C();
   c-&gt;~C();
   c-&gt;f(); // warn
 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.CtorForeignCall</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: call to virtual function of an object under construction 
+Undefined behavior: call to virtual function of an object under construction
 whose type is neither the constructors own class or one of its bases.
 <p>Source: C++11 12.7p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 class A {
 public:
   virtual void f() {};
 };

 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.CtorForeignTypeid</span><span class="lang">
 (C++)</span><div class="descr">
 Undefined behavior: the operand of <code>typeid</code> is an object under
-construction whose type is neither the constructors own class or one of its 
+construction whose type is neither the constructors own class or one of its
 bases.
 <p>Source: C++11 12.7p5.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;typeinfo&gt;
 
 class A {};
 

 
 class A {
 public:
   virtual void f() {};
 };
 
 class B {
 public:
-  B(A* a) { 
+  B(A* a) {
     (void)dynamic_cast&lt;B*&gt;(a); //warn
   }
 };
 
 class C : public A, B {
 public:
   C() : B((A*)this) {}
 };
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.MemberOrBaseRefInCatch</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: referring to any non-static member or base class of an 
-object in the handler for a function-try-block of a constructor or destructor 
+Undefined behavior: referring to any non-static member or base class of an
+object in the handler for a function-try-block of a constructor or destructor
 for that object results in undefined behavior.
 <p>Source: C++11 15.3p10.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void f() { throw 1; }
 
 class C {
   int i;

 };
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ReturnAtCatchEnd</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: a function returns when control reaches the end of a 
+Undefined behavior: a function returns when control reaches the end of a
 handler. This results in undefined behavior in a value-returning function.
 <p>Source: C++11 15.3p10.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void f() { throw 1; }
 
 int test() try {
   f();

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.QsortNonPODNonTrivial</span><span class="lang">
 (C++)</span><div class="descr">
-C++03: Undefined behavior: the objects in the array passed to qsort are of 
+C++03: Undefined behavior: the objects in the array passed to qsort are of
 non-POD type.<br>
-C++11: Undefined behavior: the objects in the array passed to qsort are of 
+C++11: Undefined behavior: the objects in the array passed to qsort are of
 non-trivial type.
 <p>Source: C++03 25.4p4; C++11 25.5p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 // C++03
 #include &lt;cstdlib&gt;
 
 

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 different.NullDerefStmtOrder</span><span class="lang">
 (C)</span><div class="descr">
-Dereferencing of the null pointer might take place. Checking the pointer for 
+Dereferencing of the null pointer might take place. Checking the pointer for
 null should be performed first.
 <br>Note: possibly an enhancement to <span class="name">
 core.NullDereference</span>.</div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 struct S {
   int x;
 };

 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 different.NullDerefCondOrder</span><span class="lang">
 (C)</span><div class="descr">
-Dereferencing of the null pointer might take place. Checking the pointer for 
+Dereferencing of the null pointer might take place. Checking the pointer for
 null should be performed first.
 <br>Note: possibly an enhancement to <span class="name">
 core.NullDereference</span>.</div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 struct S {int i;};
 
 struct S* f();

 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 different.IntegerOverflow</span><span class="lang">
 (C)</span><div class="descr">
 Integer overflow.
 <br>Note: partially handled by Clang core
 (search for 'overflow in expression' warning in Clang tests).
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/190.html">
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/190.html">
 CWE-190</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;limits.h&gt;
 
 int f(int x);
 
 void test() {

 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 different.SignExtension</span><span class="lang">
 (C)</span><div class="descr">
 Unexpected sign extension might take place.
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/194.html">
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/194.html">
 CWE-194</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 unsigned long long test(long long sll) {
   unsigned long long ull = sll; // warn
   return ull;
 }
 </pre></div>

 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 different.NumericTruncation</span><span class="lang">
 (C)</span><div class="descr">
 Numeric truncation might take place.
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/197.html">
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/197.html">
 CWE-197</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 unsigned long test(unsigned long long ull) {
   unsigned long ul = ull; // warn
   return ul;
 }
 </pre></div>

 WinAPI.CreateProcess</span><span class="lang">
 (C)</span><div class="descr">
 <code>CreateProcess()</code>: if the first parameter <code><i>
 lpApplicationName</i></code> is NULL then the executable name must be in the
 white space-delimited string pointed to by <code><i>lpCommandLine</code></i>.
 If the executable or path name has a space in it, there is a risk that a
 different executable could be run because of the way the function parses
 spaces.
-<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms682425%28v=vs.85%29.aspx">
+<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa#security-remarks">
 MSDN: CreateProcess function, Security Remarks</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;windows.h&gt;
 
 void test() {
   STARTUPINFO si;
   PROCESS_INFORMATION pi;
   CreateProcess(NULL, TEXT("C:\\Program Files\\App -L -S"),
                 NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
     // warn
 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 WinAPI.LoadLibrary</span><span class="lang">
 (C)</span><div class="descr">
 The <code>SearchPath()</code> function is used to retrieve a path to a DLL for
 a subsequent <code>LoadLibrary()</code> call.
-<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms684175%28v=vs.85%29.aspx">
+<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya#security-remarks">
 MSDN: LoadLibrary function, Security Remarks</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;windows.h&gt;
 
 HINSTANCE test() {
   char filePath[100];
   SearchPath(NULL, "file.dll", NULL, 100, filePath, NULL);
   return LoadLibrary(filePath); // warn
 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 WinAPI.WideCharToMultiByte</span><span class="lang">
 (C)</span><div class="descr">
 Buffer overrun while calling <code>WideCharToMultiByte()</code>. The size of
 the input buffer equals the number of characters in the Unicode string, while
 the size of the output buffer equals the number of bytes.
-<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/dd374130%28v=vs.85%29.aspx">
+<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte">
 MSDN: WideCharToMultiByte function</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;windows.h&gt;
 
 void test() {
   wchar_t ws[] = L"abc";
   char s[3];

 operators.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 #include &lt;vector&gt;
 
 void test() {
   std::vector&lt;int&gt; v;
   std::vector&lt;int&gt;::const_iterator it;
-  for(it = v.begin(); 
+  for(it = v.begin();
       it != v.end(); it++) {}; // warn
 }
 </pre></div></div></td>
 <td class="aligned"></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 optimization.MultipleCallsStrlen</span><span class="lang">

clang/www/analyzer/release_notes.html

<p><b>built:</b> February 19, 2014</br>
   <p><b>highlights:</b></p>
   <ul>
     <li>Includes about 9 months of change to Clang itself (improved C++11/14 support, etc.)</li>
     <li>More precise modeling of Objective-C properties, which enables the analyzer to find more bugs.</li>
     <li>Includes a new "missing call to <tt>super</tt>" warning, which looks for common pattern in iOS/OSX APIs that require chaining a call to a super class's implementation of a method.</li>
     <li>Accepts <tt>-arch arm64</tt> (which may be passed by Xcode 5.0), but for the time being analyzes code in such cases as <tt>-arch armv7s</tt>.</li>
     <li>Many sundry fixes, improvements to C++ support, etc.</li>
   </ul>
-  
 <h4 id="checker_275">checker-275</h4>
 <p><b>built:</b> May 23, 2013</br>
   <b>download:</b> <a href="downloads/checker-275.tar.bz2">checker-275.tar.bz2</a></p>
   <p><b>highlights:</b></p>
   <ul>
     <li>Xcode: Includes a new arrow layout algorithm for issue presentation within Xcode.  The goal is for interprocedural bug reports to look cleaner and less busy (and easier to read).  Feedback appreciated.</li>
     <li>Xcode: Bugs that occur within header code (e.g., C++) are now reported within the callers in the main source file.  For example, if you misuse a C++ function declared in a header the primary diagnostic will be in the caller (in the main source file).  The full expanded path, however, will show the bug in the header code as well.  These kind of cross-file issues are currently only support by Xcode, not the HTML output.</li>
     <li>This build is built with LLVM's Link-Time Optimization (LTO), which should make it slightly faster.</li>
<ul>
     <li>Significantly improves interprocedural analysis for Objective-C.</li>
     <li>Numerous bug fixes and heuristics to reduce false positives reported
       over checker-268.</li>
   </ul>
 
 <h4 id="checker_268">checker-268</h4>
 <p><b>built:</b> September 11, 2012</p>
   <p><b>highlights:</b></p>
-  
 <ul>
   <li>Adds initial interprocedural analysis support for C++ and Objective-C. This will greatly improve analysis coverage and find deeper bugs in Objective-C and C++ code.</li>
   <li>Contains a static analyzer newer than Xcode 4.4.</li>
 </ul>
 
 <p>NOTE: this checker build includes a <i>huge</i> number of changes. It has the potential to find many more bugs, but may report new kinds of false positives. We'd like to know about
 these, and any other problems you encounter. When you encounter an issue, please <a href="/filing_bugs.html">file a bug report</a>.</p>
 

 
 <p>Contains numerous stability fixes over checker-266, especially when analyzing C++11 code.</p>
 
 <h4 id="checker_265">checker-265</h4>
 <p><b>built:</b> May 8, 2012</p>
    <p><b>highlights:</b></p>
 
 <p>This release contains a fix for a major crasher introduced in checker-264, and various refinements to
-improve the precision and reduce the false positive rate of the analyzer. It also enables a new unix.MallocSizeof check, which reports 
-inconsistencies between the casted type of the return value of a 'malloc/calloc/realloc' call and the operand 
+improve the precision and reduce the false positive rate of the analyzer. It also enables a new unix.MallocSizeof check, which reports
+inconsistencies between the casted type of the return value of a 'malloc/calloc/realloc' call and the operand
 of sizeof expressions contained within its argument(s).</p>
 
 <h4 id="checker_264">checker-264</h4>
 
 <p><b>built:</b> April 26, 2012</p>
   <p><b>highlights:</b></p>
 
 <p>This release contains misc. bug fixes and performance enhancements over checker-263, including

 <p><b>highlights:</b></p>
 
 <ul>
   <li>Contains a newer version of the analyzer than the one shipped in Xcode 4.2.</li>
   <li>Adds a new security checker for looking at correct uses of the Mac OS KeyChain API.</li>
   <li>Supports ARC (please file bugs where you see issues)</li>
   <li>Major under-the-cover changes.  This should result in more precise results in some cases, but this is laying the groundwork for major improvements.  Please file bugs where you see regressions or issues.</li>
 </ul>
-    
 <h4 id="checker_257">checker-257</h4>
 
 <p><b>built: </b>May 25, 2011<br>
 <p><b>highlights:</b></p>
 
 <ul>
   <li>The analyzer is now far more aggressive with checking conformance with Core Foundation conventions.  Any function that returns a CF type must now obey the Core Foundation naming conventions, or use the <a href="/annotations.html#attr_cf_returns_retained">cf_returns_retained</a> or <a href="/annotations.html#attr_cf_returns_not_retained">cf_returns_not_retained</a> annotations.</li>
   <li>Fixed a serious regression where the analyzer would not analyze Objective-C methods in class extensions.</li>

 <ul>
   <li>Lots of bug fixes and improvements to analyzer precision (fewer false positives, possibly more bugs found).
   <li>Introductory analysis support for C++ and Objective-C++.
 </ul>
 
 <p>This build contains basic support for C++ and Objective-C++ that is ready to be tried out
   by general users.  It is still in its infancy, but establishes a baseline for things to come.  The main hope is that it can find some
   issues and have a reasonable false positive rate.</p>
-  
 <p><b>Please</b> <a href="/filing_bugs.html">file bugs</a> when you see issues of any kind so we can assess
   where development on C++ analysis support needs to be focused.</p>
-  
 <p>To try out C++ analysis support, it should work out of the box using <tt>scan-build</tt>.  If you are using this checker build
   as a replacement to the analyzer bundled with Xcode, first use the <tt>set-xcode-analyzer</tt> script to <a href="/xcode.html">change Xcode to use
   your version of the analyzer</a>.  You will then need to modify one configuration file in Xcode to enable C++ analysis support.  This can
   be done with the following steps:</p>
-  
 <ol>
   <li>Find the clang .xcspec file:
 <pre>$ cd /Developer/Library
 $ find . | grep xcspec | grep Clang
 ./Xcode/<b>&lt;SNIP&gt;</b>/Clang LLVM 1.0.xcplugin/Contents/Resources/Clang LLVM 1.0.xcspec
 </pre></li>
   <li>The exact location of the file may vary depending on your installation of Xcode.  Edit that file, and look for the string &quot;--analyze&quot;:
 <pre>

 <li>Introduces new attribute <a href="annotations.html#attr_ns_consumes_self">ns_consumes_self</a> to educate the Objective-C retain/release checker about custom &quot;init-like&quot; methods that do not follow the standard Cocoa naming conventions.</li>
 <li>Introduces new attributes <a href="annotations.html#attr_ns_consumed">ns_consumed</a> and <a href="annotations.html#attr_cf_consumed">cf_consumed</a> to educate the Objective-C retain/release checker about methods/functions that decrement the reference count of a parameter.</li>
 </ul>
 
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/scan-build.html

 
 <p>Upon completion of the build, results are then presented to the user within a
 web browser.</p>
 
 <h3>Will it work with any build system?</h3>
 <p><b>scan-build</b> has little or no knowledge about how you build your code.
 It works by overriding the <tt>CC</tt> and <tt>CXX</tt> environment variables to
 (hopefully) change your build to use a &quot;fake&quot; compiler instead of the
-one that would normally build your project. This fake compiler executes either 
-<tt>clang</tt> or <tt>gcc</tt> (depending on the platform) to compile your 
+one that would normally build your project. This fake compiler executes either
+<tt>clang</tt> or <tt>gcc</tt> (depending on the platform) to compile your
 code and then executes the static analyzer to analyze your code.</p>
 
 <p>This &quot;poor man's interposition&quot; works amazingly well in many cases
 and falls down in others. Please consult the information on this page on making
 the best use of <b>scan-build</b>, which includes getting it to work when the
 aforementioned hack fails to work.</p>
 
 </td>

 <li><a href="#iphone">Analyzing iPhone Projects</a></li>
 </ul>
 
 <h2 id="scanbuild">Getting Started</h2>
 
 <p>The <tt>scan-build</tt> command can be used to analyze an entire project by
 essentially interposing on a project's build process. This means that to run the
 analyzer using <tt>scan-build</tt>, you will use <tt>scan-build</tt> to analyze
-the source files compiled by <tt>gcc</tt>/<tt>clang</tt> during a project build. 
+the source files compiled by <tt>gcc</tt>/<tt>clang</tt> during a project build.
 This means that any files that are not compiled will also not be analyzed.</p>
 
 <h3 id="scanbuild_basicusage">Basic Usage</h3>
 
 <p>Basic usage of <tt>scan-build</tt> is designed to be simple: just place the
 word &quot;scan-build&quot; in front of your build command:</p>
 
 <pre class="code_example">
 $ <span class="code_highlight">scan-build</span> make
 $ <span class="code_highlight">scan-build</span> xcodebuild
 </pre>
 
 <p>In the first case <tt>scan-build</tt> analyzes the code of a project built
 with <tt>make</tt> and in the second case <tt>scan-build</tt> analyzes a project
 built using <tt>xcodebuild</tt>.<p>
-  
 <p>Here is the general format for invoking <tt>scan-build</tt>:</p>
 
 <pre class="code_example">
 $ <span class="code_highlight">scan-build</span> <i>[scan-build options]</i> <span class="code_highlight">&lt;command&gt;</span> <i>[command options]</i>
 </pre>
 
 <p>Operationally, <tt>scan-build</tt> literally runs &lt;command&gt; with all of the
 subsequent options passed to it. For example, one can pass <tt>-j4</tt> to

 way as it described in the Basic Usage section above. To invoke scan-build from
 an arbitrary location, add the path to the folder containing scan-build.bat to
 your PATH environment variable.</p>
 
 <p>If you have unexpected compilation/make problems when running scan-build
 with MinGW/MSYS the following information may be helpful:</p>
 
 <ul>
- <li> If getting unexpected <tt>"fatal error: no input files"</tt> while 
+ <li> If getting unexpected <tt>"fatal error: no input files"</tt> while
 building with MSYS make from the Windows cmd, try one of these solutions:</li>
  <ul>
  <li> Use MinGW <tt>mingw32-make</tt> instead of MSYS <tt>make</tt> and
 exclude the path to MSYS from PATH to prevent <tt>mingw32-make</tt> from using
 MSYS utils. MSYS utils are dependent on the MSYS runtime and they are not
 intended for being run from the Windows cmd. Specifically, makefile commands
 with backslashed quotes may be heavily corrupted when passed for execution.</li>
  <li> Run <tt>make</tt> from the sh shell:
 <pre class="code_example">
 $ <span class="code_highlight">scan-build</span> <i>[scan-build options]</i> sh -c "make <i>[make options]</i>"
 </pre></li>
  </ul>
- <li> If getting <tt>"Error : *** target pattern contains no `%'"</tt> while 
+ <li> If getting <tt>"Error : *** target pattern contains no `%'"</tt> while
 using GNU Make 3.81, try to use another version of make.</li>
 </ul>
 
 <h3 id="scanbuild_otheroptions">Other Options</h3>
 
 <p>As mentioned above, extra options can be passed to <tt>scan-build</tt>. These
 options prefix the build command. For example:</p>
 

 <tr><td><b>-v</b></td><td>Verbose output from scan-build and the analyzer. <b>A
 second and third "-v" increases verbosity</b>, and is useful for filing bug
 reports against the analyzer.</td></tr>
 
 <tr><td><b>-V</b></td><td>View analysis results in a web browser when the build
 command completes.</td></tr>
 
 <tr><td><b>--use-analyzer Xcode</b><br><i>or</i><br>
-<b>--use-analyzer [path to clang]</b></td><td><tt>scan-build</tt> uses the 
-'clang' executable relative to itself for static analysis. One can override this 
-behavior with this option by using the 'clang' packaged with Xcode (on OS X) or 
+<b>--use-analyzer [path to clang]</b></td><td><tt>scan-build</tt> uses the
+'clang' executable relative to itself for static analysis. One can override this
+behavior with this option by using the 'clang' packaged with Xcode (on OS X) or
 from the PATH.</p></td></tr> </table>
 
 <p>A complete list of options can be obtained by running <tt>scan-build</tt>
 with no arguments.</p>
 
 <h3 id="scanbuild_output">Output of scan-build</h3>
 
 <p>

 <tt>ccc-analyzer</tt>. The program <tt>ccc-analyzer</tt> acts like a fake
 compiler, forwarding its command line arguments over to the compiler to perform
 regular compilation and <tt>clang</tt> to perform static analysis.</p>
 
 <p>Running <tt>configure</tt> typically generates makefiles that have hardwired
 paths to the compiler, and by running <tt>configure</tt> through
 <tt>scan-build</tt> that path is set to <tt>ccc-analyzer</tt>.</p>
 
-<!-- 
+<!--
 <h2 id="Debugging">Debugging the Analyzer</h2>
 
 <p>This section provides information on debugging the analyzer, and troubleshooting
 it when you have problems analyzing a particular project.</p>
 
 <h3>How it Works</h3>
 
 <p>To analyze a project, <tt>scan-build</tt> simply sets the environment variable

 
 <pre class="code_example">
 $ scan-build xcodebuild -configuration Debug -sdk iphonesimulator3.0
 </pre>
 
 <h3>Gotcha: using the right compiler</h3>
 
 <p>Recall that <b>scan-build</b> analyzes your project by using a compiler to
-compile the project and <tt>clang</tt> to analyze your project. The script uses 
-simple heuristics to determine which compiler should be used (it defaults to 
+compile the project and <tt>clang</tt> to analyze your project. The script uses
+simple heuristics to determine which compiler should be used (it defaults to
 <tt>clang</tt> on Darwin and <tt>gcc</tt> on other platforms). When analyzing
 iPhone projects, <b>scan-build</b> may pick the wrong compiler than the one
-Xcode would use to build your project. For example, this could be because 
-multiple versions of a compiler may be installed on your system, especially if 
+Xcode would use to build your project. For example, this could be because
+multiple versions of a compiler may be installed on your system, especially if
 you are developing for the iPhone.</p>
 
 <p>When compiling your application to run on the simulator, it is important that <b>scan-build</b>
 finds the correct version of <tt>gcc/clang</tt>. Otherwise, you may see strange build
 errors that only happen when you run <tt>scan-build</tt>.
 
 <p><b>scan-build</b> provides the <tt>--use-cc</tt> and <tt>--use-c++</tt>
 options to hardwire which compiler scan-build should use for building your code.
 Note that although you are chiefly interested in analyzing your project, keep in
 mind that running the analyzer is intimately tied to the build, and not being
 able to compile your code means it won't get fully analyzed (if at all).</p>
 
 <p>If you aren't certain which compiler Xcode uses to build your project, try
 just running <tt>xcodebuild</tt> (without <b>scan-build</b>). You should see the
 full path to the compiler that Xcode is using, and use that as an argument to
 <tt>--use-cc</tt>.</p>
 
 </div>
 </div>
 </body>
 </html>
-

clang/www/analyzer/xcode.html

<ul>
   consider using <a href="scan-build.html"><b>scan-build</b></a>.
 </ul>
 
 
 <h2>Getting Started</h2>
 
 <p>Xcode is available as a free download from Apple on the <a
 href="https://itunes.apple.com/us/app/xcode/id497799835?mt=12">Mac
-App Store</a>, with <a 
+App Store</a>, with <a
 href="https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/Analyze.html#//apple_ref/doc/uid/TP40009975-CH4-SW1">instructions
 available</a> for using the analyzer.</p>
 
 <h2>Using open source analyzer builds with Xcode</h2>
 
 <p>By default, Xcode uses the version of <tt>clang</tt> that came bundled with
 it to analyze your code. It is possible to change Xcode's behavior to use an
 alternate version of <tt>clang</tt> for this purpose while continuing to use

 <pre class="code_example">
 $ sudo set-xcode-analyzer --use-xcode-clang
 </pre>
 
 </div>
 </div>
 </body>
 </html>
-

clang/www/comparison.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>Comparing Clang to other open source compilers</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 <body>
   <!--#include virtual="menu.html.incl"-->
   <div id="content">
     <h1>Clang vs Other Open Source Compilers</h1>
-    
     <p>Building an entirely new compiler front-end is a big task, and it isn't
        always clear to people why we decided to do this.  Here we compare Clang
        and its goals to other open source compiler front-ends that are
        available.  We restrict the discussion to very specific objective points
        to avoid controversy where possible.  Also, software is infinitely
-       mutable, so we don't talk about little details that can be fixed with 
-       a reasonable amount of effort: we'll talk about issues that are 
+       mutable, so we don't talk about little details that can be fixed with
+       a reasonable amount of effort: we'll talk about issues that are
        difficult to fix for architectural or political reasons.</p>
-       
     <p>The goal of this list is to describe how differences in goals lead to
        different strengths and weaknesses, not to make some compiler look bad.
        This will hopefully help you to evaluate whether using Clang is a good
        idea for your personal goals.  Because we don't know specifically what
        <em>you</em> want to do, we describe the features of these compilers in
        terms of <em>our</em> goals: if you are only interested in static
        analysis, you may not care that something lacks codegen support, for
        example.</p>
-       
     <p>Please email <a href="get_involved.html">cfe-dev</a> if you think we should add another compiler to this
        list or if you think some characterization is unfair here.</p>
-    
     <ul>
     <li><a href="#gcc">Clang vs GCC</a> (GNU Compiler Collection)</li>
     <li><a href="#elsa">Clang vs Elsa</a> (Elkhound-based C++ Parser)</li>
     <li><a href="#pcc">Clang vs PCC</a> (Portable C Compiler)</li>
     </ul>
-    
-    
     <!--=====================================================================-->
     <h2><a name="gcc">Clang vs GCC (GNU Compiler Collection)</a></h2>
     <!--=====================================================================-->
-    
     <p>Pro's of GCC vs Clang:</p>
-    
     <ul>
     <li>GCC supports languages that Clang does not aim to, such as Java, Ada,
         FORTRAN, Go, etc.</li>
     <li>GCC supports more targets than LLVM.</li>
     <li>GCC supports many language extensions, some of which are not implemented
     by Clang. For instance, in C mode, GCC supports
-    <a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html">nested
+    <a href="https://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html">nested
     functions</a> and has an
     <a href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html">extension
     allowing VLAs in structs</a>.
     </ul>
 
     <p>Pro's of Clang vs GCC:</p>
-    
     <ul>
-    <li>The Clang ASTs and design are intended to be <a 
+    <li>The Clang ASTs and design are intended to be <a
         href="features.html#simplecode">easily understandable</a> by
         anyone who is familiar with the languages involved and who has a basic
         understanding of how a compiler works.  GCC has a very old codebase
         which presents a steep learning curve to new developers.</li>
     <li>Clang is designed as an API from its inception, allowing it to be reused
         by source analysis tools, refactoring, IDEs (etc) as well as for code
         generation.  GCC is built as a monolithic static compiler, which makes
         it extremely difficult to use as an API and integrate into other tools.
-        Further, its historic design and <a 
-        href="http://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a>
-        <a href="http://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a> 
+        Further, its historic design and <a
+        href="https://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a>
+        <a href="https://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a>
         makes it difficult to decouple the front-end from the rest of the
         compiler. </li>
     <li>Various GCC design decisions make it very difficult to reuse: its build
         system is difficult to modify, you can't link multiple targets into one
         binary, you can't link multiple front-ends into one binary, it uses a
         custom garbage collector, uses global variables extensively, is not
         reentrant or multi-threadable, etc.  Clang has none of these problems.
         </li>
     <li>Clang does not implicitly simplify code as it parses it like GCC does.
         Doing so causes many problems for source analysis tools: as one simple
         example, if you write "x-x" in your source code, the GCC AST will
         contain "0", with no mention of 'x'.  This is extremely bad for a
         refactoring tool that wants to rename 'x'.</li>
-    <li>Clang can serialize its AST out to disk and read it back into another 
+    <li>Clang can serialize its AST out to disk and read it back into another
         program, which is useful for whole program analysis.  GCC does not have
-        this.  GCC's PCH mechanism (which is just a dump of the compiler 
-        memory image) is related, but is architecturally only 
-        able to read the dump back into the exact same executable as the one 
+        this.  GCC's PCH mechanism (which is just a dump of the compiler
+        memory image) is related, but is architecturally only
+        able to read the dump back into the exact same executable as the one
         that produced it (it is not a structured format).</li>
     <li>Clang is <a href="features.html#performance">much faster and uses far
         less memory</a> than GCC.</li>
     <li>Clang has been designed from the start to provide extremely clear and
         concise diagnostics (error and warning messages), and includes support
         for <a href="diagnostics.html">expressive diagnostics</a>.
         Modern versions of GCC have made significant advances in this area,
         incorporating various Clang features such as preserving typedefs in
         diagnostics and showing macro expansions, but GCC is still catching
         up.</li>
     <li>GCC is licensed under the GPL license. <a href="features.html#license">
         Clang uses a BSD license,</a> which allows it to be embedded in
         software that is not GPL-licensed.</li>
     <li>Clang inherits a number of features from its use of LLVM as a backend,
         including support for a bytecode representation for intermediate code,
         pluggable optimizers, link-time optimization support, Just-In-Time
         compilation, ability to link in multiple code generators, etc.</li>
     <li><a href="compatibility.html#cxx">Clang's support for C++</a> is more
         compliant than GCC's in many ways.</li>
     <li>Clang supports
-        <a href="http://clang.llvm.org/docs/LanguageExtensions.html">many language
+        <a href="https://clang.llvm.org/docs/LanguageExtensions.html">many language
         extensions</a>, some of which are not implemented by GCC. For instance,
         Clang provides attributes for checking thread safety and extended vector
         types.</li>
     </ul>
 
     <!--=====================================================================-->
     <h2><a name="elsa">Clang vs Elsa (Elkhound-based C++ Parser)</a></h2>
     <!--=====================================================================-->
-    
     <p>Pro's of Elsa vs Clang:</p>
-    
     <ul>
     <li>Elsa's parser and AST is designed to be easily extensible by adding
         grammar rules.  Clang has a very simple and easily hackable parser,
         but requires you to write C++ code to do it.</li>
     </ul>
-    
     <p>Pro's of Clang vs Elsa:</p>
-    
     <ul>
     <li>Clang's C and C++ support is far more mature and practically useful than
         Elsa's, and includes many C++'11 features.</li>
     <li>The Elsa community is extremely small and major development work seems
-        to have ceased in 2005. Work continued to be used by other small 
+        to have ceased in 2005. Work continued to be used by other small
         projects (e.g. Oink), but Oink is apparently dead now too.  Clang has a
         vibrant community including developers that
         are paid to work on it full time.  In practice this means that you can
         file bugs against Clang and they will often be fixed for you.  If you
         use Elsa, you are (mostly) on your own for bug fixes and feature
         enhancements.</li>
     <li>Elsa is not built as a stack of reusable libraries like Clang is.  It is
         very difficult to use part of Elsa without the whole front-end.  For
         example, you cannot use Elsa to parse C/ObjC code without building an
         AST.  You can do this in Clang and it is much faster than building an
         AST.</li>
     <li>Elsa does not have an integrated preprocessor, which makes it extremely
         difficult to accurately map from a source location in the AST back to
         its original position before preprocessing.  Like GCC, it does not keep
         track of macro expansions.</li>
-    <li>Elsa is even slower and uses more memory than GCC, which itself requires 
+    <li>Elsa is even slower and uses more memory than GCC, which itself requires
         far more space and time than Clang.</li>
     <li>Elsa only does partial semantic analysis.  It is intended to work on
         code that is already validated by GCC, so it does not do many semantic
         checks required by the languages it implements.</li>
     <li>Elsa does not support Objective-C.</li>
     <li>Elsa does not support native code generation.</li>
     </ul>
-    
-    
     <!--=====================================================================-->
     <h2><a name="pcc">Clang vs PCC (Portable C Compiler)</a></h2>
     <!--=====================================================================-->
-    
     <p>Pro's of PCC vs Clang:</p>
-    
     <ul>
     <li>The PCC source base is very small and builds quickly with just a C
         compiler.</li>
     </ul>
-    
     <p>Pro's of Clang vs PCC:</p>
-    
     <ul>
     <li>PCC dates from the 1970's and has been dormant for most of that time.
         The Clang and LLVM communities are very active.</li>
     <li>PCC doesn't support Objective-C or C++ and doesn't aim to support
         C++.</li>
     <li>PCC's code generation is very limited compared to LLVM.  It produces very
         inefficient code and does not support many important targets.</li>
     <li>Like Elsa, PCC's does not have an integrated preprocessor, making it
         extremely difficult to use it for source analysis tools.</li>
     </ul>
   </div>
 </body>
 </html>

clang/www/compatibility.html

 <p>Clang strives to both conform to current language standards (up to C11
   and C++11) and also to implement many widely-used extensions available
   in other compilers, so that most correct code will "just work" when
   compiled with Clang. However, Clang is more strict than other
   popular compilers, and may reject incorrect code that other
   compilers allow. This page documents common compatibility and
   portability issues with Clang to help you understand and fix the
   problem in your code when Clang emits an error message.</p>
-  
 <ul>
   <li><a href="#c">C compatibility</a>
     <ul>
       <li><a href="#inline">C99 inline functions</a></li>
       <li><a href="#vector_builtins">"missing" vector __builtin functions</a></li>
       <li><a href="#lvalue-cast">Lvalue casts</a></li>
       <li><a href="#blocks-in-protected-scope">Jumps to within <tt>__block</tt> variable scope</a></li>
       <li><a href="#block-variable-initialization">Non-initialization of <tt>__block</tt> variables</a></li>

 <!-- ======================================================================= -->
 <h3 id="vector_builtins">"missing" vector __builtin functions</h3>
 <!-- ======================================================================= -->
 
 <p>The Intel and AMD manuals document a number "<tt>&lt;*mmintrin.h&gt;</tt>"
 header files, which define a standardized API for accessing vector operations
 on X86 CPUs.  These functions have names like <tt>_mm_xor_ps</tt> and
 <tt>_mm256_addsub_pd</tt>.  Compilers have leeway to implement these functions
-however they want.  Since Clang supports an excellent set of <a 
+however they want.  Since Clang supports an excellent set of <a
 href="../docs/LanguageExtensions.html#vectors">native vector operations</a>,
-the Clang headers implement these interfaces in terms of the native vector 
+the Clang headers implement these interfaces in terms of the native vector
 operations.
 </p>
 
 <p>In contrast, GCC implements these functions mostly as a 1-to-1 mapping to
 builtin function calls, like <tt>__builtin_ia32_paddw128</tt>.  These builtin
 functions are an internal implementation detail of GCC, and are not portable to
 the Intel compiler, the Microsoft compiler, or Clang.  If you get build errors
 mentioning these, the fix is simple: switch to the *mmintrin.h functions.</p>

 within these declarations unless they are marked <code>extern</code>.</p>
 
 <p>Variables may still be declared in an @implementation.</p>
 
 <pre>
 @interface XX
 int a;         // not allowed in clang
 int b = 1;     // not allowed in clang
-extern int c;  // allowed 
+extern int c;  // allowed
 @end
 
 </pre>
 
 <!-- ======================================================================= -->
 <h2 id="cxx">C++ compatibility</h2>
 <!-- ======================================================================= -->
 

 
 void f(X x);
 void g(X x) {
   f(x); <i>// error: X has a deleted copy constructor</i>
 }
 </pre>
 
 <p>This affects some early C++11 code, including Boost's popular <a
-href="http://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm"><tt>shared_ptr</tt></a>
+href="https://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm"><tt>shared_ptr</tt></a>
 up to version 1.47.0. The fix for Boost's <tt>shared_ptr</tt> is
 <a href="https://svn.boost.org/trac/boost/changeset/73202">available here</a>.</p>
 
 <!-- ======================================================================= -->
 <h2 id="objective-cxx">Objective-C++ compatibility</h2>
 <!-- ======================================================================= -->
 
 <!-- ======================================================================= -->

clang/www/cxx_compatibility.html

 
 <div id="content">
 
 <!-- ======================================================================= -->
 <h1>Clang's C++ Compatibility</h1>
 <!-- ======================================================================= -->
 
   <p>The Clang C++ compatibility page has moved. You will be directed <a href="compatibility.html#c++">to its new home</a> in 5 seconds.</p>
-  
 </div>
 </body>
 </html>

clang/www/cxx_dr_status.html

 <table width="689" border="1" cellspacing="0">
   <tr>
     <th>Number</th>
     <th>Status</th>
     <th>Issue title</th>
     <th>Available in Clang?</th>
   </tr>
   <tr id="1">
-    <td><a href="http://wg21.link/cwg1">1</a></td>
+    <td><a href="https://wg21.link/cwg1">1</a></td>
     <td>TC1</td>
     <td>What if two using-declarations refer to the same function but the declarations introduce different default-arguments?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="2">
-    <td><a href="http://wg21.link/cwg2">2</a></td>
+    <td><a href="https://wg21.link/cwg2">2</a></td>
     <td>drafting</td>
     <td>How can dependent names be used in member declarations that appear outside of the class template definition?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="3">
-    <td><a href="http://wg21.link/cwg3">3</a></td>
+    <td><a href="https://wg21.link/cwg3">3</a></td>
     <td>NAD</td>
     <td>The template compilation model rules render some explicit specialization declarations not visible during instantiation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="4">
-    <td><a href="http://wg21.link/cwg4">4</a></td>
+    <td><a href="https://wg21.link/cwg4">4</a></td>
     <td>CD1</td>
     <td>Does extern "C" affect the linkage of function names with internal linkage?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="5">
-    <td><a href="http://wg21.link/cwg5">5</a></td>
+    <td><a href="https://wg21.link/cwg5">5</a></td>
     <td>CD1</td>
     <td>CV-qualifiers and type conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="6">
-    <td><a href="http://wg21.link/cwg6">6</a></td>
+    <td><a href="https://wg21.link/cwg6">6</a></td>
     <td>open</td>
     <td>Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="7">
-    <td><a href="http://wg21.link/cwg7">7</a></td>
+    <td><a href="https://wg21.link/cwg7">7</a></td>
     <td>NAD</td>
     <td>Can a class with a private virtual base class be derived from?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="8">
-    <td><a href="http://wg21.link/cwg8">8</a></td>
+    <td><a href="https://wg21.link/cwg8">8</a></td>
     <td>CD1</td>
     <td>Access to template arguments used in a function return type and in the nested name specifier</td>
     <td class="full" align="center">Duplicate of <a href="#45">45</a></td>
   </tr>
   <tr id="9">
-    <td><a href="http://wg21.link/cwg9">9</a></td>
+    <td><a href="https://wg21.link/cwg9">9</a></td>
     <td>CD1</td>
     <td>Clarification of access to base class members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="10">
-    <td><a href="http://wg21.link/cwg10">10</a></td>
+    <td><a href="https://wg21.link/cwg10">10</a></td>
     <td>CD1</td>
     <td>Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?</td>
     <td class="full" align="center">Duplicate of <a href="#45">45</a></td>
   </tr>
   <tr id="11">
-    <td><a href="http://wg21.link/cwg11">11</a></td>
+    <td><a href="https://wg21.link/cwg11">11</a></td>
     <td>CD1</td>
     <td>How do the keywords typename/template interact with using-declarations?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="12">
-    <td><a href="http://wg21.link/cwg12">12</a></td>
+    <td><a href="https://wg21.link/cwg12">12</a></td>
     <td>dup</td>
     <td>Default arguments on different declarations for the same function and the Koenig lookup</td>
     <td class="full" align="center">Superseded by <a href="#239">239</a></td>
   </tr>
   <tr id="13">
-    <td><a href="http://wg21.link/cwg13">13</a></td>
+    <td><a href="https://wg21.link/cwg13">13</a></td>
     <td>NAD</td>
     <td>extern "C" for Parameters of Function Templates</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="14">
-    <td><a href="http://wg21.link/cwg14">14</a></td>
+    <td><a href="https://wg21.link/cwg14">14</a></td>
     <td>NAD</td>
     <td>extern "C" functions and declarations in different namespaces</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="15">
-    <td><a href="http://wg21.link/cwg15">15</a></td>
+    <td><a href="https://wg21.link/cwg15">15</a></td>
     <td>dup</td>
     <td>Default arguments for parameters of function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="16">
-    <td><a href="http://wg21.link/cwg16">16</a></td>
+    <td><a href="https://wg21.link/cwg16">16</a></td>
     <td>CD1</td>
     <td>Access to members of indirect private base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="17">
-    <td><a href="http://wg21.link/cwg17">17</a></td>
+    <td><a href="https://wg21.link/cwg17">17</a></td>
     <td>NAD</td>
     <td>Footnote 99 should discuss the naming class when describing members that can be accessed from friends</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="18">
-    <td><a href="http://wg21.link/cwg18">18</a></td>
+    <td><a href="https://wg21.link/cwg18">18</a></td>
     <td>NAD</td>
     <td>f(TYPE) where TYPE is void should be allowed</td>
     <td class="full" align="center">Superseded by <a href="#577">577</a></td>
   </tr>
   <tr id="19">
-    <td><a href="http://wg21.link/cwg19">19</a></td>
+    <td><a href="https://wg21.link/cwg19">19</a></td>
     <td>NAD</td>
     <td>Clarify protected member access</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="20">
-    <td><a href="http://wg21.link/cwg20">20</a></td>
+    <td><a href="https://wg21.link/cwg20">20</a></td>
     <td>TC1</td>
     <td>Some clarifications needed for 12.8 para 15</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="21">
-    <td><a href="http://wg21.link/cwg21">21</a></td>
+    <td><a href="https://wg21.link/cwg21">21</a></td>
     <td>TC1</td>
     <td>Can a default argument for a template parameter appear in a friend declaration?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="22">
-    <td><a href="http://wg21.link/cwg22">22</a></td>
+    <td><a href="https://wg21.link/cwg22">22</a></td>
     <td>TC1</td>
     <td>Template parameter with a default argument that refers to itself</td>
     <td class="full" align="center">Superseded by <a href="#481">481</a></td>
   </tr>
   <tr id="23">
-    <td><a href="http://wg21.link/cwg23">23</a></td>
+    <td><a href="https://wg21.link/cwg23">23</a></td>
     <td>NAD</td>
     <td>Some questions regarding partial ordering of function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="24">
-    <td><a href="http://wg21.link/cwg24">24</a></td>
+    <td><a href="https://wg21.link/cwg24">24</a></td>
     <td>TC1</td>
     <td>Errors in examples in 14.7.3</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="25">
-    <td><a href="http://wg21.link/cwg25">25</a></td>
+    <td><a href="https://wg21.link/cwg25">25</a></td>
     <td>TC1</td>
     <td>Exception specifications and pointers to members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="26">
-    <td><a href="http://wg21.link/cwg26">26</a></td>
+    <td><a href="https://wg21.link/cwg26">26</a></td>
     <td>NAD</td>
     <td>Copy constructors and default arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="27">
-    <td><a href="http://wg21.link/cwg27">27</a></td>
+    <td><a href="https://wg21.link/cwg27">27</a></td>
     <td>NAD</td>
     <td>Overload ambiguities for builtin ?: prototypes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="28">
-    <td><a href="http://wg21.link/cwg28">28</a></td>
+    <td><a href="https://wg21.link/cwg28">28</a></td>
     <td>CD1</td>
     <td>'exit', 'signal' and static object destruction</td>
     <td class="na" align="center">N/A (Library DR)</td>
   </tr>
   <tr id="29">
-    <td><a href="http://wg21.link/cwg29">29</a></td>
+    <td><a href="https://wg21.link/cwg29">29</a></td>
     <td>CD1</td>
     <td>Linkage of locally declared functions</td>
     <td class="full" align="center">Clang 3.4</td>
   </tr>
   <tr id="30">
-    <td><a href="http://wg21.link/cwg30">30</a></td>
+    <td><a href="https://wg21.link/cwg30">30</a></td>
     <td>TC1</td>
     <td>Valid uses of "<TT>::template</TT>"</td>
     <td class="full" align="center">Superseded by <a href="#468">468</a> (C++11 onwards)</td>
   </tr>
   <tr id="31">
-    <td><a href="http://wg21.link/cwg31">31</a></td>
+    <td><a href="https://wg21.link/cwg31">31</a></td>
     <td>NAD</td>
     <td>Looking up new/delete</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="32">
-    <td><a href="http://wg21.link/cwg32">32</a></td>
+    <td><a href="https://wg21.link/cwg32">32</a></td>
     <td>TC1</td>
     <td>Clarification of explicit instantiation of non-exported templates</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="33">
-    <td><a href="http://wg21.link/cwg33">33</a></td>
+    <td><a href="https://wg21.link/cwg33">33</a></td>
     <td>TC1</td>
     <td>Argument dependent lookup and overloaded functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="34">
-    <td><a href="http://wg21.link/cwg34">34</a></td>
+    <td><a href="https://wg21.link/cwg34">34</a></td>
     <td>NAD</td>
     <td>Argument dependent lookup and points of instantiation</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="35">
-    <td><a href="http://wg21.link/cwg35">35</a></td>
+    <td><a href="https://wg21.link/cwg35">35</a></td>
     <td>TC1</td>
     <td>Definition of default-initialization</td>
     <td class="full" align="center">Duplicate of <a href="#178">178</a></td>
   </tr>
   <tr class="open" id="36">
-    <td><a href="http://wg21.link/cwg36">36</a></td>
+    <td><a href="https://wg21.link/cwg36">36</a></td>
     <td>open</td>
     <td><I>using-declaration</I>s in multiple-declaration contexts</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="37">
-    <td><a href="http://wg21.link/cwg37">37</a></td>
+    <td><a href="https://wg21.link/cwg37">37</a></td>
     <td>NAD</td>
     <td>When is uncaught_exception() true?</td>
     <td class="none" align="center">Superseded by <a href="#475">475</a></td>
   </tr>
   <tr id="38">
-    <td><a href="http://wg21.link/cwg38">38</a></td>
+    <td><a href="https://wg21.link/cwg38">38</a></td>
     <td>TC1</td>
     <td>Explicit template arguments and operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="39">
-    <td><a href="http://wg21.link/cwg39">39</a></td>
+    <td><a href="https://wg21.link/cwg39">39</a></td>
     <td>CD1</td>
     <td>Conflicting ambiguity rules</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="40">
-    <td><a href="http://wg21.link/cwg40">40</a></td>
+    <td><a href="https://wg21.link/cwg40">40</a></td>
     <td>TC1</td>
     <td>Syntax of <I>declarator-id</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="41">
-    <td><a href="http://wg21.link/cwg41">41</a></td>
+    <td><a href="https://wg21.link/cwg41">41</a></td>
     <td>TC1</td>
     <td>Clarification of lookup of names after declarator-id</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="42">
-    <td><a href="http://wg21.link/cwg42">42</a></td>
+    <td><a href="https://wg21.link/cwg42">42</a></td>
     <td>NAD</td>
     <td>Redefining names from base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="43">
-    <td><a href="http://wg21.link/cwg43">43</a></td>
+    <td><a href="https://wg21.link/cwg43">43</a></td>
     <td>TC1</td>
     <td>Copying base classes (PODs) using memcpy</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="44">
-    <td><a href="http://wg21.link/cwg44">44</a></td>
+    <td><a href="https://wg21.link/cwg44">44</a></td>
     <td>CD1</td>
     <td>Member specializations</td>
     <td class="partial" align="center">Superseded by <a href="#727">727</a></td>
   </tr>
   <tr id="45">
-    <td><a href="http://wg21.link/cwg45">45</a></td>
+    <td><a href="https://wg21.link/cwg45">45</a></td>
     <td>CD1</td>
     <td>Access to nested classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="46">
-    <td><a href="http://wg21.link/cwg46">46</a></td>
+    <td><a href="https://wg21.link/cwg46">46</a></td>
     <td>NAD</td>
     <td>Explicit instantiation of member templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="47">
-    <td><a href="http://wg21.link/cwg47">47</a></td>
+    <td><a href="https://wg21.link/cwg47">47</a></td>
     <td>NAD</td>
     <td>Template friend issues</td>
     <td class="full" align="center">Superseded by <a href="#329">329</a></td>
   </tr>
   <tr id="48">
-    <td><a href="http://wg21.link/cwg48">48</a></td>
+    <td><a href="https://wg21.link/cwg48">48</a></td>
     <td>TC1</td>
     <td>Definitions of unused static members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="49">
-    <td><a href="http://wg21.link/cwg49">49</a></td>
+    <td><a href="https://wg21.link/cwg49">49</a></td>
     <td>TC1</td>
     <td>Restriction on non-type, non-value template arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="50">
-    <td><a href="http://wg21.link/cwg50">50</a></td>
+    <td><a href="https://wg21.link/cwg50">50</a></td>
     <td>NAD</td>
     <td>Converting pointer to incomplete type to same type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="51">
-    <td><a href="http://wg21.link/cwg51">51</a></td>
+    <td><a href="https://wg21.link/cwg51">51</a></td>
     <td>TC1</td>
     <td>Overloading and user-defined conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="52">
-    <td><a href="http://wg21.link/cwg52">52</a></td>
+    <td><a href="https://wg21.link/cwg52">52</a></td>
     <td>TC1</td>
     <td>Non-static members, member selection and access checking</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="53">
-    <td><a href="http://wg21.link/cwg53">53</a></td>
+    <td><a href="https://wg21.link/cwg53">53</a></td>
     <td>TC1</td>
     <td>Lvalue-to-rvalue conversion before certain static_casts</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="54">
-    <td><a href="http://wg21.link/cwg54">54</a></td>
+    <td><a href="https://wg21.link/cwg54">54</a></td>
     <td>CD1</td>
     <td>Static_cast from private base to derived class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="55">
-    <td><a href="http://wg21.link/cwg55">55</a></td>
+    <td><a href="https://wg21.link/cwg55">55</a></td>
     <td>NAD</td>
     <td>Adding/subtracting pointer and enumeration value</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="56">
-    <td><a href="http://wg21.link/cwg56">56</a></td>
+    <td><a href="https://wg21.link/cwg56">56</a></td>
     <td>TC1</td>
     <td>Redeclaring typedefs within classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="57">
-    <td><a href="http://wg21.link/cwg57">57</a></td>
+    <td><a href="https://wg21.link/cwg57">57</a></td>
     <td>open</td>
     <td>Empty unions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="58">
-    <td><a href="http://wg21.link/cwg58">58</a></td>
+    <td><a href="https://wg21.link/cwg58">58</a></td>
     <td>CD1</td>
     <td>Signedness of bit fields of enum type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="59">
-    <td><a href="http://wg21.link/cwg59">59</a></td>
+    <td><a href="https://wg21.link/cwg59">59</a></td>
     <td>TC1</td>
     <td>Clarification of overloading and UDC to reference type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="60">
-    <td><a href="http://wg21.link/cwg60">60</a></td>
+    <td><a href="https://wg21.link/cwg60">60</a></td>
     <td>CD1</td>
     <td>Reference binding and valid conversion sequences</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="61">
-    <td><a href="http://wg21.link/cwg61">61</a></td>
+    <td><a href="https://wg21.link/cwg61">61</a></td>
     <td>NAD</td>
     <td>Address of static member function "<TT>&amp;p-&gt;f</TT>"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="62">
-    <td><a href="http://wg21.link/cwg62">62</a></td>
+    <td><a href="https://wg21.link/cwg62">62</a></td>
     <td>CD1</td>
     <td>Unnamed members of classes used as type parameters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="63">
-    <td><a href="http://wg21.link/cwg63">63</a></td>
+    <td><a href="https://wg21.link/cwg63">63</a></td>
     <td>CD1</td>
     <td>Class instantiation from pointer conversion to void*, null and self</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="64">
-    <td><a href="http://wg21.link/cwg64">64</a></td>
+    <td><a href="https://wg21.link/cwg64">64</a></td>
     <td>TC1</td>
     <td>Partial ordering to disambiguate explicit specialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="65">
-    <td><a href="http://wg21.link/cwg65">65</a></td>
+    <td><a href="https://wg21.link/cwg65">65</a></td>
     <td>TC1</td>
     <td>Typo in default argument example</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="66">
-    <td><a href="http://wg21.link/cwg66">66</a></td>
+    <td><a href="https://wg21.link/cwg66">66</a></td>
     <td>NAD</td>
     <td>Visibility of default args vs overloads added after using-declaration</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="67">
-    <td><a href="http://wg21.link/cwg67">67</a></td>
+    <td><a href="https://wg21.link/cwg67">67</a></td>
     <td>TC1</td>
     <td>Evaluation of left side of object-expression</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="68">
-    <td><a href="http://wg21.link/cwg68">68</a></td>
+    <td><a href="https://wg21.link/cwg68">68</a></td>
     <td>TC1</td>
     <td>Grammar does not allow "friend class A&lt;int&gt;;"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="69">
-    <td><a href="http://wg21.link/cwg69">69</a></td>
+    <td><a href="https://wg21.link/cwg69">69</a></td>
     <td>TC1</td>
     <td>Storage class specifiers on template declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="70">
-    <td><a href="http://wg21.link/cwg70">70</a></td>
+    <td><a href="https://wg21.link/cwg70">70</a></td>
     <td>CD1</td>
     <td>Is an array bound a nondeduced context?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="71">
-    <td><a href="http://wg21.link/cwg71">71</a></td>
+    <td><a href="https://wg21.link/cwg71">71</a></td>
     <td>NAD</td>
     <td>Incorrect cross reference</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="72">
-    <td><a href="http://wg21.link/cwg72">72</a></td>
+    <td><a href="https://wg21.link/cwg72">72</a></td>
     <td>dup</td>
     <td>Linkage and storage class specifiers for templates</td>
     <td class="full" align="center">Duplicate of <a href="#69">69</a></td>
   </tr>
   <tr id="73">
-    <td><a href="http://wg21.link/cwg73">73</a></td>
+    <td><a href="https://wg21.link/cwg73">73</a></td>
     <td>TC1</td>
     <td>Pointer equality</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="74">
-    <td><a href="http://wg21.link/cwg74">74</a></td>
+    <td><a href="https://wg21.link/cwg74">74</a></td>
     <td>TC1</td>
     <td>Enumeration value in direct-new-declarator</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="75">
-    <td><a href="http://wg21.link/cwg75">75</a></td>
+    <td><a href="https://wg21.link/cwg75">75</a></td>
     <td>TC1</td>
     <td>In-class initialized members must be const</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="76">
-    <td><a href="http://wg21.link/cwg76">76</a></td>
+    <td><a href="https://wg21.link/cwg76">76</a></td>
     <td>TC1</td>
     <td>Are const volatile variables considered "constant expressions"?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="77">
-    <td><a href="http://wg21.link/cwg77">77</a></td>
+    <td><a href="https://wg21.link/cwg77">77</a></td>
     <td>CD1</td>
     <td>The definition of friend does not allow nested classes to be friends</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="78">
-    <td><a href="http://wg21.link/cwg78">78</a></td>
+    <td><a href="https://wg21.link/cwg78">78</a></td>
     <td>CD1</td>
     <td>Section 8.5 paragraph 9 should state it only applies to non-static objects</td>
     <td class="none" align="center">Superseded by <a href="#????">????</a></td>
   </tr>
   <tr id="79">
-    <td><a href="http://wg21.link/cwg79">79</a></td>
+    <td><a href="https://wg21.link/cwg79">79</a></td>
     <td>dup</td>
     <td>Alignment and placement new</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="80">
-    <td><a href="http://wg21.link/cwg80">80</a></td>
+    <td><a href="https://wg21.link/cwg80">80</a></td>
     <td>TC1</td>
     <td>Class members with same name as class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="81">
-    <td><a href="http://wg21.link/cwg81">81</a></td>
+    <td><a href="https://wg21.link/cwg81">81</a></td>
     <td>NAD</td>
     <td>Null pointers and C compatibility</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="82">
-    <td><a href="http://wg21.link/cwg82">82</a></td>
+    <td><a href="https://wg21.link/cwg82">82</a></td>
     <td>dup</td>
     <td>Definition of "using" a constant expression</td>
     <td class="full" align="center">Duplicate of <a href="#48">48</a></td>
   </tr>
   <tr id="83">
-    <td><a href="http://wg21.link/cwg83">83</a></td>
+    <td><a href="https://wg21.link/cwg83">83</a></td>
     <td>TC1</td>
     <td>Overloading and deprecated conversion of string literal</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="84">
-    <td><a href="http://wg21.link/cwg84">84</a></td>
+    <td><a href="https://wg21.link/cwg84">84</a></td>
     <td>TC1</td>
     <td>Overloading and conversion loophole used by <TT>auto_ptr</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="85">
-    <td><a href="http://wg21.link/cwg85">85</a></td>
+    <td><a href="https://wg21.link/cwg85">85</a></td>
     <td>TC1</td>
     <td>Redeclaration of member class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="86">
-    <td><a href="http://wg21.link/cwg86">86</a></td>
+    <td><a href="https://wg21.link/cwg86">86</a></td>
     <td>CD1</td>
     <td>Lifetime of temporaries in query expressions</td>
     <td class="full" align="center">Duplicate of <a href="#446">446</a></td>
   </tr>
   <tr id="87">
-    <td><a href="http://wg21.link/cwg87">87</a></td>
+    <td><a href="https://wg21.link/cwg87">87</a></td>
     <td>CD1</td>
     <td>Exception specifications on function parameters</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="88">
-    <td><a href="http://wg21.link/cwg88">88</a></td>
+    <td><a href="https://wg21.link/cwg88">88</a></td>
     <td>NAD</td>
     <td>Specialization of member constant templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="89">
-    <td><a href="http://wg21.link/cwg89">89</a></td>
+    <td><a href="https://wg21.link/cwg89">89</a></td>
     <td>TC1</td>
     <td>Object lifetime does not account for reference rebinding</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="90">
-    <td><a href="http://wg21.link/cwg90">90</a></td>
+    <td><a href="https://wg21.link/cwg90">90</a></td>
     <td>TC1</td>
     <td>Should the enclosing class be an "associated class" too?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="91">
-    <td><a href="http://wg21.link/cwg91">91</a></td>
+    <td><a href="https://wg21.link/cwg91">91</a></td>
     <td>NAD</td>
     <td>A union's associated types should include the union itself</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="92">
-    <td><a href="http://wg21.link/cwg92">92</a></td>
+    <td><a href="https://wg21.link/cwg92">92</a></td>
     <td>CD4</td>
     <td>Should <I>exception-specification</I>s be part of the type system?</td>
     <td class="full" align="center">Clang 4 (C++17 onwards)</td>
   </tr>
   <tr id="93">
-    <td><a href="http://wg21.link/cwg93">93</a></td>
+    <td><a href="https://wg21.link/cwg93">93</a></td>
     <td>TC1</td>
     <td>Missing word in 3.8 <U>basic.life</U> paragraph 2</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="94">
-    <td><a href="http://wg21.link/cwg94">94</a></td>
+    <td><a href="https://wg21.link/cwg94">94</a></td>
     <td>TC1</td>
     <td>Inconsistencies in the descriptions of constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="95">
-    <td><a href="http://wg21.link/cwg95">95</a></td>
+    <td><a href="https://wg21.link/cwg95">95</a></td>
     <td>NAD</td>
     <td>Elaborated type specifiers referencing names declared in friend decls</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="96">
-    <td><a href="http://wg21.link/cwg96">96</a></td>
+    <td><a href="https://wg21.link/cwg96">96</a></td>
     <td>C++11</td>
     <td>Syntactic disambiguation using the <TT>template</TT> keyword</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="97">
-    <td><a href="http://wg21.link/cwg97">97</a></td>
+    <td><a href="https://wg21.link/cwg97">97</a></td>
     <td>NAD</td>
     <td>Use of bool constants in integral constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="98">
-    <td><a href="http://wg21.link/cwg98">98</a></td>
+    <td><a href="https://wg21.link/cwg98">98</a></td>
     <td>TC1</td>
     <td>Branching into try block</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="99">
-    <td><a href="http://wg21.link/cwg99">99</a></td>
+    <td><a href="https://wg21.link/cwg99">99</a></td>
     <td>NAD</td>
     <td>Partial ordering, references and cv-qualifiers</td>
     <td class="full" align="center">Superseded by <a href="#214">214</a></td>
   </tr>
   <tr id="100">
-    <td><a href="http://wg21.link/cwg100">100</a></td>
+    <td><a href="https://wg21.link/cwg100">100</a></td>
     <td>TC1</td>
     <td>Clarify why string literals are not allowed as template arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="101">
-    <td><a href="http://wg21.link/cwg101">101</a></td>
+    <td><a href="https://wg21.link/cwg101">101</a></td>
     <td>TC1</td>
     <td>Redeclaration of extern "C" names via using-declarations</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="102">
-    <td><a href="http://wg21.link/cwg102">102</a></td>
+    <td><a href="https://wg21.link/cwg102">102</a></td>
     <td>NAD</td>
     <td>Operator lookup rules do not work well with parts of the library</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="103">
-    <td><a href="http://wg21.link/cwg103">103</a></td>
+    <td><a href="https://wg21.link/cwg103">103</a></td>
     <td>TC1</td>
     <td>Is it <I>extended-namespace-definition</I> or <I>extension-namespace-definition</I> ?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="104">
-    <td><a href="http://wg21.link/cwg104">104</a></td>
+    <td><a href="https://wg21.link/cwg104">104</a></td>
     <td>NAD</td>
     <td>Destroying the exception temp when no handler is found</td>
     <td class="na" align="center">N/A (Library DR)</td>
   </tr>
   <tr id="105">
-    <td><a href="http://wg21.link/cwg105">105</a></td>
+    <td><a href="https://wg21.link/cwg105">105</a></td>
     <td>TC1</td>
     <td>Meaning of "template function"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="106">
-    <td><a href="http://wg21.link/cwg106">106</a></td>
+    <td><a href="https://wg21.link/cwg106">106</a></td>
     <td>CD1</td>
     <td>Creating references to references during template deduction/instantiation</td>
     <td class="full" align="center">Superseded by <a href="#540">540</a></td>
   </tr>
   <tr id="107">
-    <td><a href="http://wg21.link/cwg107">107</a></td>
+    <td><a href="https://wg21.link/cwg107">107</a></td>
     <td>NAD</td>
     <td>Linkage of operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="108">
-    <td><a href="http://wg21.link/cwg108">108</a></td>
+    <td><a href="https://wg21.link/cwg108">108</a></td>
     <td>TC1</td>
     <td>Are classes nested in templates dependent?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="109">
-    <td><a href="http://wg21.link/cwg109">109</a></td>
+    <td><a href="https://wg21.link/cwg109">109</a></td>
     <td>NAD</td>
     <td>Allowing <TT>::template</TT> in <I>using-declaration</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="110">
-    <td><a href="http://wg21.link/cwg110">110</a></td>
+    <td><a href="https://wg21.link/cwg110">110</a></td>
     <td>open</td>
     <td>Can template functions and classes be declared in the same scope?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="111">
-    <td><a href="http://wg21.link/cwg111">111</a></td>
+    <td><a href="https://wg21.link/cwg111">111</a></td>
     <td>NAD</td>
     <td>Copy constructors and cv-qualifiers</td>
     <td class="full" align="center">Duplicate of <a href="#535">535</a></td>
   </tr>
   <tr id="112">
-    <td><a href="http://wg21.link/cwg112">112</a></td>
+    <td><a href="https://wg21.link/cwg112">112</a></td>
     <td>CD1</td>
     <td>Array types and cv-qualifiers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="113">
-    <td><a href="http://wg21.link/cwg113">113</a></td>
+    <td><a href="https://wg21.link/cwg113">113</a></td>
     <td>CD1</td>
     <td>Visibility of called function</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="114">
-    <td><a href="http://wg21.link/cwg114">114</a></td>
+    <td><a href="https://wg21.link/cwg114">114</a></td>
     <td>NAD</td>
     <td>Virtual overriding by template member function specializations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="115">
-    <td><a href="http://wg21.link/cwg115">115</a></td>
+    <td><a href="https://wg21.link/cwg115">115</a></td>
     <td>CD1</td>
     <td>Address of template-id</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="116">
-    <td><a href="http://wg21.link/cwg116">116</a></td>
+    <td><a href="https://wg21.link/cwg116">116</a></td>
     <td>TC1</td>
     <td>Equivalent and functionally-equivalent function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="117">
-    <td><a href="http://wg21.link/cwg117">117</a></td>
+    <td><a href="https://wg21.link/cwg117">117</a></td>
     <td>NAD</td>
     <td>Timing of destruction of temporaries</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="118">
-    <td><a href="http://wg21.link/cwg118">118</a></td>
+    <td><a href="https://wg21.link/cwg118">118</a></td>
     <td>CD1</td>
     <td>Calls via pointers to virtual member functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="119">
-    <td><a href="http://wg21.link/cwg119">119</a></td>
+    <td><a href="https://wg21.link/cwg119">119</a></td>
     <td>CD1</td>
     <td>Object lifetime and aggregate initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="120">
-    <td><a href="http://wg21.link/cwg120">120</a></td>
+    <td><a href="https://wg21.link/cwg120">120</a></td>
     <td>TC1</td>
     <td>Nonexistent non-terminal <I>qualified-name</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="121">
-    <td><a href="http://wg21.link/cwg121">121</a></td>
+    <td><a href="https://wg21.link/cwg121">121</a></td>
     <td>TC1</td>
     <td>Dependent type names with non-dependent <I>nested-name-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="122">
-    <td><a href="http://wg21.link/cwg122">122</a></td>
+    <td><a href="https://wg21.link/cwg122">122</a></td>
     <td>CD1</td>
     <td><I>template-id</I>s as <I>unqualified-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="123">
-    <td><a href="http://wg21.link/cwg123">123</a></td>
+    <td><a href="https://wg21.link/cwg123">123</a></td>
     <td>TC1</td>
     <td>Bad cross-reference</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="124">
-    <td><a href="http://wg21.link/cwg124">124</a></td>
+    <td><a href="https://wg21.link/cwg124">124</a></td>
     <td>CD1</td>
     <td>Lifetime of temporaries in default initialization of class arrays</td>
     <td class="none" align="center">Duplicate of <a href="#201">201</a></td>
   </tr>
   <tr id="125">
-    <td><a href="http://wg21.link/cwg125">125</a></td>
+    <td><a href="https://wg21.link/cwg125">125</a></td>
     <td>CD1</td>
     <td>Ambiguity in <TT>friend</TT> declaration syntax</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="126">
-    <td><a href="http://wg21.link/cwg126">126</a></td>
+    <td><a href="https://wg21.link/cwg126">126</a></td>
     <td>TC1</td>
     <td>Exception specifications and <TT>const</TT></td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="127">
-    <td><a href="http://wg21.link/cwg127">127</a></td>
+    <td><a href="https://wg21.link/cwg127">127</a></td>
     <td>TC1</td>
     <td>Ambiguity in description of matching deallocation function</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="128">
-    <td><a href="http://wg21.link/cwg128">128</a></td>
+    <td><a href="https://wg21.link/cwg128">128</a></td>
     <td>TC1</td>
     <td>Casting between enum types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="129">
-    <td><a href="http://wg21.link/cwg129">129</a></td>
+    <td><a href="https://wg21.link/cwg129">129</a></td>
     <td>CD3</td>
     <td>Stability of uninitialized auto variables</td>
     <td class="full" align="center">Duplicate of <a href="#616">616</a></td>
   </tr>
   <tr id="130">
-    <td><a href="http://wg21.link/cwg130">130</a></td>
+    <td><a href="https://wg21.link/cwg130">130</a></td>
     <td>NAD</td>
     <td>Sequence points and <I>new-expression</I>s</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="131">
-    <td><a href="http://wg21.link/cwg131">131</a></td>
+    <td><a href="https://wg21.link/cwg131">131</a></td>
     <td>TC1</td>
     <td>Typo in Lao characters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="132">
-    <td><a href="http://wg21.link/cwg132">132</a></td>
+    <td><a href="https://wg21.link/cwg132">132</a></td>
     <td>NAD</td>
     <td>Local types and linkage</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="133">
-    <td><a href="http://wg21.link/cwg133">133</a></td>
+    <td><a href="https://wg21.link/cwg133">133</a></td>
     <td>dup</td>
     <td>Exception specifications and checking</td>
     <td class="none" align="center">Duplicate of <a href="#87">87</a></td>
   </tr>
   <tr id="134">
-    <td><a href="http://wg21.link/cwg134">134</a></td>
+    <td><a href="https://wg21.link/cwg134">134</a></td>
     <td>TC1</td>
     <td>Template classes and <I>declarator-id</I>s</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="135">
-    <td><a href="http://wg21.link/cwg135">135</a></td>
+    <td><a href="https://wg21.link/cwg135">135</a></td>
     <td>TC1</td>
     <td>Class type in in-class member function definitions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="136">
-    <td><a href="http://wg21.link/cwg136">136</a></td>
+    <td><a href="https://wg21.link/cwg136">136</a></td>
     <td>CD1</td>
     <td>Default arguments and friend declarations</td>
     <td class="full" align="center">Clang 3.4</td>
   </tr>
   <tr id="137">
-    <td><a href="http://wg21.link/cwg137">137</a></td>
+    <td><a href="https://wg21.link/cwg137">137</a></td>
     <td>TC1</td>
     <td><TT>static_cast</TT> of <I>cv</I> <TT>void*</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="138">
-    <td><a href="http://wg21.link/cwg138">138</a></td>
+    <td><a href="https://wg21.link/cwg138">138</a></td>
     <td>drafting</td>
     <td>Friend declaration name lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="139">
-    <td><a href="http://wg21.link/cwg139">139</a></td>
+    <td><a href="https://wg21.link/cwg139">139</a></td>
     <td>CD1</td>
     <td>Error in <TT>friend</TT> lookup example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="140">
-    <td><a href="http://wg21.link/cwg140">140</a></td>
+    <td><a href="https://wg21.link/cwg140">140</a></td>
     <td>CD1</td>
     <td>Agreement of parameter declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="141">
-    <td><a href="http://wg21.link/cwg141">141</a></td>
+    <td><a href="https://wg21.link/cwg141">141</a></td>
     <td>CD1</td>
     <td>Non-member function templates in member access expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="142">
-    <td><a href="http://wg21.link/cwg142">142</a></td>
+    <td><a href="https://wg21.link/cwg142">142</a></td>
     <td>TC1</td>
     <td>Injection-related errors in access example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="143">
-    <td><a href="http://wg21.link/cwg143">143</a></td>
+    <td><a href="https://wg21.link/cwg143">143</a></td>
     <td>CD1</td>
     <td>Friends and Koenig lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="144">
-    <td><a href="http://wg21.link/cwg144">144</a></td>
+    <td><a href="https://wg21.link/cwg144">144</a></td>
     <td>open</td>
     <td>Position of <TT>friend</TT> specifier</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="145">
-    <td><a href="http://wg21.link/cwg145">145</a></td>
+    <td><a href="https://wg21.link/cwg145">145</a></td>
     <td>TC1</td>
     <td>Deprecation of prefix <TT>++</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="146">
-    <td><a href="http://wg21.link/cwg146">146</a></td>
+    <td><a href="https://wg21.link/cwg146">146</a></td>
     <td>open</td>
     <td>Floating-point zero</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="147">
-    <td><a href="http://wg21.link/cwg147">147</a></td>
+    <td><a href="https://wg21.link/cwg147">147</a></td>
     <td>TC1</td>
     <td>Naming the constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="148">
-    <td><a href="http://wg21.link/cwg148">148</a></td>
+    <td><a href="https://wg21.link/cwg148">148</a></td>
     <td>TC1</td>
     <td>POD classes and pointers to members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="149">
-    <td><a href="http://wg21.link/cwg149">149</a></td>
+    <td><a href="https://wg21.link/cwg149">149</a></td>
     <td>TC1</td>
     <td>Accessibility and ambiguity</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="150">
-    <td><a href="http://wg21.link/cwg150">150</a></td>
+    <td><a href="https://wg21.link/cwg150">150</a></td>
     <td>C++17</td>
     <td>Template template parameters and default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="151">
-    <td><a href="http://wg21.link/cwg151">151</a></td>
+    <td><a href="https://wg21.link/cwg151">151</a></td>
     <td>TC1</td>
     <td>Terminology of zero-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="152">
-    <td><a href="http://wg21.link/cwg152">152</a></td>
+    <td><a href="https://wg21.link/cwg152">152</a></td>
     <td>TC1</td>
     <td><TT>explicit</TT> copy constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="153">
-    <td><a href="http://wg21.link/cwg153">153</a></td>
+    <td><a href="https://wg21.link/cwg153">153</a></td>
     <td>TC1</td>
     <td>Misleading wording (rank of conversion)</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="154">
-    <td><a href="http://wg21.link/cwg154">154</a></td>
+    <td><a href="https://wg21.link/cwg154">154</a></td>
     <td>NAD</td>
     <td>Anonymous unions in unnamed namespaces</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="155">
-    <td><a href="http://wg21.link/cwg155">155</a></td>
+    <td><a href="https://wg21.link/cwg155">155</a></td>
     <td>dup</td>
     <td>Brace initializer for scalar</td>
     <td class="full" align="center">Duplicate of <a href="#632">632</a></td>
   </tr>
   <tr class="open" id="156">
-    <td><a href="http://wg21.link/cwg156">156</a></td>
+    <td><a href="https://wg21.link/cwg156">156</a></td>
     <td>drafting</td>
     <td>Name lookup for conversion functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="157">
-    <td><a href="http://wg21.link/cwg157">157</a></td>
+    <td><a href="https://wg21.link/cwg157">157</a></td>
     <td>open</td>
     <td>Omitted typedef declarator</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="158">
-    <td><a href="http://wg21.link/cwg158">158</a></td>
+    <td><a href="https://wg21.link/cwg158">158</a></td>
     <td>CD1</td>
     <td>Aliasing and qualification conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="159">
-    <td><a href="http://wg21.link/cwg159">159</a></td>
+    <td><a href="https://wg21.link/cwg159">159</a></td>
     <td>TC1</td>
     <td>Namespace qualification in declarators</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="160">
-    <td><a href="http://wg21.link/cwg160">160</a></td>
+    <td><a href="https://wg21.link/cwg160">160</a></td>
     <td>CD1</td>
     <td>Missing <TT>std::</TT> qualification</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="161">
-    <td><a href="http://wg21.link/cwg161">161</a></td>
+    <td><a href="https://wg21.link/cwg161">161</a></td>
     <td>TC1</td>
     <td>Access to protected nested type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="162">
-    <td><a href="http://wg21.link/cwg162">162</a></td>
+    <td><a href="https://wg21.link/cwg162">162</a></td>
     <td>CD1</td>
     <td>(<TT>&amp;C::f)()</TT> with nonstatic members</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="163">
-    <td><a href="http://wg21.link/cwg163">163</a></td>
+    <td><a href="https://wg21.link/cwg163">163</a></td>
     <td>TC1</td>
     <td>Description of subaggregate initializer</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="164">
-    <td><a href="http://wg21.link/cwg164">164</a></td>
+    <td><a href="https://wg21.link/cwg164">164</a></td>
     <td>TC1</td>
     <td>Overlap between Koenig and normal lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="165">
-    <td><a href="http://wg21.link/cwg165">165</a></td>
+    <td><a href="https://wg21.link/cwg165">165</a></td>
     <td>NAD</td>
     <td>Definitions of friends and block-scope externs</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="166">
-    <td><a href="http://wg21.link/cwg166">166</a></td>
+    <td><a href="https://wg21.link/cwg166">166</a></td>
     <td>TC1</td>
     <td>Friend declarations of <I>template-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="167">
-    <td><a href="http://wg21.link/cwg167">167</a></td>
+    <td><a href="https://wg21.link/cwg167">167</a></td>
     <td>NAD</td>
     <td>Deprecating static functions</td>
     <td class="none" align="center">Superseded by <a href="#1012">1012</a></td>
   </tr>
   <tr id="168">
-    <td><a href="http://wg21.link/cwg168">168</a></td>
+    <td><a href="https://wg21.link/cwg168">168</a></td>
     <td>NAD</td>
     <td>C linkage for static member functions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="169">
-    <td><a href="http://wg21.link/cwg169">169</a></td>
+    <td><a href="https://wg21.link/cwg169">169</a></td>
     <td>NAD</td>
     <td><I>template-id</I>s in <I>using-declaration</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="170">
-    <td><a href="http://wg21.link/cwg170">170</a></td>
+    <td><a href="https://wg21.link/cwg170">170</a></td>
     <td>drafting</td>
     <td>Pointer-to-member conversions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="171">
-    <td><a href="http://wg21.link/cwg171">171</a></td>
+    <td><a href="https://wg21.link/cwg171">171</a></td>
     <td>TC1</td>
     <td>Global namespace scope</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="172">
-    <td><a href="http://wg21.link/cwg172">172</a></td>
+    <td><a href="https://wg21.link/cwg172">172</a></td>
     <td>CD1</td>
     <td>Unsigned int as underlying type of enum</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="173">
-    <td><a href="http://wg21.link/cwg173">173</a></td>
+    <td><a href="https://wg21.link/cwg173">173</a></td>
     <td>TC1</td>
     <td>Constraints on execution character set</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="174">
-    <td><a href="http://wg21.link/cwg174">174</a></td>
+    <td><a href="https://wg21.link/cwg174">174</a></td>
     <td>NAD</td>
     <td>Undeprecating global static</td>
     <td class="none" align="center">Superseded by <a href="#1012">1012</a></td>
   </tr>
   <tr id="175">
-    <td><a href="http://wg21.link/cwg175">175</a></td>
+    <td><a href="https://wg21.link/cwg175">175</a></td>
     <td>CD1</td>
     <td>Class name injection and base name access</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="176">
-    <td><a href="http://wg21.link/cwg176">176</a></td>
+    <td><a href="https://wg21.link/cwg176">176</a></td>
     <td>TC1</td>
     <td>Name injection and templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="177">
-    <td><a href="http://wg21.link/cwg177">177</a></td>
+    <td><a href="https://wg21.link/cwg177">177</a></td>
     <td>CD1</td>
     <td>Lvalues vs rvalues in copy-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="178">
-    <td><a href="http://wg21.link/cwg178">178</a></td>
+    <td><a href="https://wg21.link/cwg178">178</a></td>
     <td>TC1</td>
     <td>More on value-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="179">
-    <td><a href="http://wg21.link/cwg179">179</a></td>
+    <td><a href="https://wg21.link/cwg179">179</a></td>
     <td>TC1</td>
     <td>Function pointers and subtraction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="180">
-    <td><a href="http://wg21.link/cwg180">180</a></td>
+    <td><a href="https://wg21.link/cwg180">180</a></td>
     <td>CD1</td>
     <td><TT>typename</TT> and elaborated types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="181">
-    <td><a href="http://wg21.link/cwg181">181</a></td>
+    <td><a href="https://wg21.link/cwg181">181</a></td>
     <td>TC1</td>
     <td>Errors in template <I>template-parameter</I> example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="182">
-    <td><a href="http://wg21.link/cwg182">182</a></td>
+    <td><a href="https://wg21.link/cwg182">182</a></td>
     <td>NAD</td>
     <td>Access checking on explicit specializations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="183">
-    <td><a href="http://wg21.link/cwg183">183</a></td>
+    <td><a href="https://wg21.link/cwg183">183</a></td>
     <td>TC1</td>
     <td><TT>typename</TT> in explicit specializations</td>
     <td class="full" align="center">Superseded by <a href="#382">382</a></td>
   </tr>
   <tr id="184">
-    <td><a href="http://wg21.link/cwg184">184</a></td>
+    <td><a href="https://wg21.link/cwg184">184</a></td>
     <td>CD1</td>
     <td>Default arguments in template <I>template-parameter</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="185">
-    <td><a href="http://wg21.link/cwg185">185</a></td>
+    <td><a href="https://wg21.link/cwg185">185</a></td>
     <td>TC1</td>
     <td>"Named" temporaries and copy elision</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="186">
-    <td><a href="http://wg21.link/cwg186">186</a></td>
+    <td><a href="https://wg21.link/cwg186">186</a></td>
     <td>open</td>
     <td>Name hiding and template <I>template-parameter</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="187">
-    <td><a href="http://wg21.link/cwg187">187</a></td>
+    <td><a href="https://wg21.link/cwg187">187</a></td>
     <td>TC1</td>
     <td>Scope of template parameter names</td>
     <td class="full" align="center">Superseded by <a href="#481">481</a></td>
   </tr>
   <tr id="188">
-    <td><a href="http://wg21.link/cwg188">188</a></td>
+    <td><a href="https://wg21.link/cwg188">188</a></td>
     <td>TC1</td>
     <td>Comma operator and rvalue conversion</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="189">
-    <td><a href="http://wg21.link/cwg189">189</a></td>
+    <td><a href="https://wg21.link/cwg189">189</a></td>
     <td>drafting</td>
     <td>Definition of <I>operator</I> and <I>punctuator</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="190">
-    <td><a href="http://wg21.link/cwg190">190</a></td>
+    <td><a href="https://wg21.link/cwg190">190</a></td>
     <td>TC1</td>
     <td>Layout-compatible POD-struct types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="191">
-    <td><a href="http://wg21.link/cwg191">191</a></td>
+    <td><a href="https://wg21.link/cwg191">191</a></td>
     <td>open</td>
     <td>Name lookup does not handle complex nesting</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="192">
-    <td><a href="http://wg21.link/cwg192">192</a></td>
+    <td><a href="https://wg21.link/cwg192">192</a></td>
     <td>drafting</td>
     <td>Name lookup in parameters</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="193">
-    <td><a href="http://wg21.link/cwg193">193</a></td>
+    <td><a href="https://wg21.link/cwg193">193</a></td>
     <td>TC1</td>
     <td>Order of destruction of local automatics of destructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="194">
-    <td><a href="http://wg21.link/cwg194">194</a></td>
+    <td><a href="https://wg21.link/cwg194">194</a></td>
     <td>TC1</td>
     <td>Identifying constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="195">
-    <td><a href="http://wg21.link/cwg195">195</a></td>
+    <td><a href="https://wg21.link/cwg195">195</a></td>
     <td>CD1</td>
     <td>Converting between function and object pointers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="196">
-    <td><a href="http://wg21.link/cwg196">196</a></td>
+    <td><a href="https://wg21.link/cwg196">196</a></td>
     <td>open</td>
     <td>Arguments to deallocation functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="197">
-    <td><a href="http://wg21.link/cwg197">197</a></td>
+    <td><a href="https://wg21.link/cwg197">197</a></td>
     <td>CD1</td>
     <td>Issues with two-stage lookup of dependent names</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="198">
-    <td><a href="http://wg21.link/cwg198">198</a></td>
+    <td><a href="https://wg21.link/cwg198">198</a></td>
     <td>CD1</td>
     <td>Definition of "use" in local and nested classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="199">
-    <td><a href="http://wg21.link/cwg199">199</a></td>
+    <td><a href="https://wg21.link/cwg199">199</a></td>
     <td>CD1</td>
     <td>Order of destruction of temporaries</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="200">
-    <td><a href="http://wg21.link/cwg200">200</a></td>
+    <td><a href="https://wg21.link/cwg200">200</a></td>
     <td>dup</td>
     <td>Partial ordering and explicit arguments</td>
     <td class="full" align="center">Duplicate of <a href="#214">214</a></td>
   </tr>
   <tr id="201">
-    <td><a href="http://wg21.link/cwg201">201</a></td>
+    <td><a href="https://wg21.link/cwg201">201</a></td>
     <td>CD1</td>
     <td>Order of destruction of temporaries in initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="202">
-    <td><a href="http://wg21.link/cwg202">202</a></td>
+    <td><a href="https://wg21.link/cwg202">202</a></td>
     <td>TC1</td>
     <td>Use of overloaded function name</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="203">
-    <td><a href="http://wg21.link/cwg203">203</a></td>
+    <td><a href="https://wg21.link/cwg203">203</a></td>
     <td>NAD</td>
     <td>Type of address-of-member expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="204">
-    <td><a href="http://wg21.link/cwg204">204</a></td>
+    <td><a href="https://wg21.link/cwg204">204</a></td>
     <td>CD1</td>
     <td>Exported class templates</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="205">
-    <td><a href="http://wg21.link/cwg205">205</a></td>
+    <td><a href="https://wg21.link/cwg205">205</a></td>
     <td>drafting</td>
     <td>Templates and static data members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="206">
-    <td><a href="http://wg21.link/cwg206">206</a></td>
+    <td><a href="https://wg21.link/cwg206">206</a></td>
     <td>TC1</td>
     <td>Semantic constraints on non-dependent names</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="207">
-    <td><a href="http://wg21.link/cwg207">207</a></td>
+    <td><a href="https://wg21.link/cwg207">207</a></td>
     <td>CD1</td>
     <td><I>using-declaration</I>s and protected access</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="208">
-    <td><a href="http://wg21.link/cwg208">208</a></td>
+    <td><a href="https://wg21.link/cwg208">208</a></td>
     <td>CD1</td>
     <td>Rethrowing exceptions in nested handlers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="209">
-    <td><a href="http://wg21.link/cwg209">209</a></td>
+    <td><a href="https://wg21.link/cwg209">209</a></td>
     <td>NAD</td>
-    <td>Must friend declaration names be
+    <td>Must friend declaration names be
 accessible?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="210">
-    <td><a href="http://wg21.link/cwg210">210</a></td>
+    <td><a href="https://wg21.link/cwg210">210</a></td>
     <td>TC1</td>
     <td>What is the type matched by an exception handler?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="211">
-    <td><a href="http://wg21.link/cwg211">211</a></td>
+    <td><a href="https://wg21.link/cwg211">211</a></td>
     <td>NAD</td>
     <td>Constructors should not be allowed to return normally after an exception</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="212">
-    <td><a href="http://wg21.link/cwg212">212</a></td>
+    <td><a href="https://wg21.link/cwg212">212</a></td>
     <td>CD4</td>
     <td>Implicit instantiation is not described clearly enough</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="213">
-    <td><a href="http://wg21.link/cwg213">213</a></td>
+    <td><a href="https://wg21.link/cwg213">213</a></td>
     <td>TC1</td>
     <td>Lookup in dependent base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="214">
-    <td><a href="http://wg21.link/cwg214">214</a></td>
+    <td><a href="https://wg21.link/cwg214">214</a></td>
     <td>CD1</td>
     <td>Partial ordering of function templates is underspecified</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="215">
-    <td><a href="http://wg21.link/cwg215">215</a></td>
+    <td><a href="https://wg21.link/cwg215">215</a></td>
     <td>CD1</td>
     <td>Template parameters are not allowed in <I>nested-name-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="216">
-    <td><a href="http://wg21.link/cwg216">216</a></td>
+    <td><a href="https://wg21.link/cwg216">216</a></td>
     <td>CD1</td>
     <td>Linkage of nameless class-scope enumeration types</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="217">
-    <td><a href="http://wg21.link/cwg217">217</a></td>
+    <td><a href="https://wg21.link/cwg217">217</a></td>
     <td>TC1</td>
     <td>Default arguments for non-template member functions of class templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="218">
-    <td><a href="http://wg21.link/cwg218">218</a></td>
+    <td><a href="https://wg21.link/cwg218">218</a></td>
     <td>CD1</td>
     <td>Specification of Koenig lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="219">
-    <td><a href="http://wg21.link/cwg219">219</a></td>
+    <td><a href="https://wg21.link/cwg219">219</a></td>
     <td>NAD</td>
     <td>Cannot defend against destructors that throw exceptions</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="220">
-    <td><a href="http://wg21.link/cwg220">220</a></td>
+    <td><a href="https://wg21.link/cwg220">220</a></td>
     <td>CD1</td>
     <td>All deallocation functions should be required not to throw</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="221">
-    <td><a href="http://wg21.link/cwg221">221</a></td>
+    <td><a href="https://wg21.link/cwg221">221</a></td>
     <td>CD1</td>
     <td>Must compound assignment operators be member functions?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="222">
-    <td><a href="http://wg21.link/cwg222">222</a></td>
+    <td><a href="https://wg21.link/cwg222">222</a></td>
     <td>CD1</td>
     <td>Sequence points and lvalue-returning operators</td>
     <td class="full" align="center">Duplicate of <a href="#637">637</a></td>
   </tr>
   <tr id="223">
-    <td><a href="http://wg21.link/cwg223">223</a></td>
+    <td><a href="https://wg21.link/cwg223">223</a></td>
     <td>CD3</td>
     <td>The meaning of deprecation</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="224">
-    <td><a href="http://wg21.link/cwg224">224</a></td>
+    <td><a href="https://wg21.link/cwg224">224</a></td>
     <td>CD1</td>
     <td>Definition of dependent names</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="225">
-    <td><a href="http://wg21.link/cwg225">225</a></td>
+    <td><a href="https://wg21.link/cwg225">225</a></td>
     <td>NAD</td>
     <td>Koenig lookup and fundamental types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="226">
-    <td><a href="http://wg21.link/cwg226">226</a></td>
+    <td><a href="https://wg21.link/cwg226">226</a></td>
     <td>CD1</td>
     <td>Default template arguments for function templates</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="227">
-    <td><a href="http://wg21.link/cwg227">227</a></td>
+    <td><a href="https://wg21.link/cwg227">227</a></td>
     <td>TC1</td>
     <td>How many scopes in an <TT>if</TT> statement?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="228">
-    <td><a href="http://wg21.link/cwg228">228</a></td>
+    <td><a href="https://wg21.link/cwg228">228</a></td>
     <td>CD1</td>
     <td>Use of <TT>template</TT> keyword with non-member templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="229">
-    <td><a href="http://wg21.link/cwg229">229</a></td>
+    <td><a href="https://wg21.link/cwg229">229</a></td>
     <td>NAD</td>
     <td>Partial specialization of function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="230">
-    <td><a href="http://wg21.link/cwg230">230</a></td>
+    <td><a href="https://wg21.link/cwg230">230</a></td>
     <td>NAD</td>
     <td>Calls to pure virtual functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="231">
-    <td><a href="http://wg21.link/cwg231">231</a></td>
+    <td><a href="https://wg21.link/cwg231">231</a></td>
     <td>NAD</td>
     <td>Visibility of names after <I>using-directive</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="232">
-    <td><a href="http://wg21.link/cwg232">232</a></td>
+    <td><a href="https://wg21.link/cwg232">232</a></td>
     <td>drafting</td>
     <td>Is indirection through a null pointer undefined behavior?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="233">
-    <td><a href="http://wg21.link/cwg233">233</a></td>
+    <td><a href="https://wg21.link/cwg233">233</a></td>
     <td>open</td>
     <td>References vs pointers in UDC overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="234">
-    <td><a href="http://wg21.link/cwg234">234</a></td>
+    <td><a href="https://wg21.link/cwg234">234</a></td>
     <td>NAD</td>
     <td>Reuse of base class subobjects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="235">
-    <td><a href="http://wg21.link/cwg235">235</a></td>
+    <td><a href="https://wg21.link/cwg235">235</a></td>
     <td>TC1</td>
     <td>Assignment vs initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="236">
-    <td><a href="http://wg21.link/cwg236">236</a></td>
+    <td><a href="https://wg21.link/cwg236">236</a></td>
     <td>NAD</td>
     <td>Explicit temporaries and integral constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="237">
-    <td><a href="http://wg21.link/cwg237">237</a></td>
+    <td><a href="https://wg21.link/cwg237">237</a></td>
     <td>CD1</td>
     <td>Explicit instantiation and base class members</td>
     <td class="full" align="center">Duplicate of <a href="#470">470</a></td>
   </tr>
   <tr id="238">
-    <td><a href="http://wg21.link/cwg238">238</a></td>
+    <td><a href="https://wg21.link/cwg238">238</a></td>
     <td>CD4</td>
     <td>Precision and accuracy constraints on floating point</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="239">
-    <td><a href="http://wg21.link/cwg239">239</a></td>
+    <td><a href="https://wg21.link/cwg239">239</a></td>
     <td>CD1</td>
     <td>Footnote 116 and Koenig lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="240">
-    <td><a href="http://wg21.link/cwg240">240</a></td>
+    <td><a href="https://wg21.link/cwg240">240</a></td>
     <td>CD3</td>
     <td>Uninitialized values and undefined behavior</td>
     <td class="full" align="center">Duplicate of <a href="#616">616</a></td>
   </tr>
   <tr id="241">
-    <td><a href="http://wg21.link/cwg241">241</a></td>
+    <td><a href="https://wg21.link/cwg241">241</a></td>
     <td>TC1</td>
     <td>Error in example in 14.8.1</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="242">
-    <td><a href="http://wg21.link/cwg242">242</a></td>
+    <td><a href="https://wg21.link/cwg242">242</a></td>
     <td>CD4</td>
     <td>Interpretation of old-style casts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="243">
-    <td><a href="http://wg21.link/cwg243">243</a></td>
+    <td><a href="https://wg21.link/cwg243">243</a></td>
     <td>NAD</td>
     <td>Weighting of conversion functions in direct-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="244">
-    <td><a href="http://wg21.link/cwg244">244</a></td>
+    <td><a href="https://wg21.link/cwg244">244</a></td>
     <td>CD1</td>
     <td>Destructor lookup</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="245">
-    <td><a href="http://wg21.link/cwg245">245</a></td>
+    <td><a href="https://wg21.link/cwg245">245</a></td>
     <td>CD1</td>
     <td>Name lookup in <I>elaborated-type-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="246">
-    <td><a href="http://wg21.link/cwg246">246</a></td>
+    <td><a href="https://wg21.link/cwg246">246</a></td>
     <td>CD1</td>
     <td>Jumps in <I>function-try-block</I> handlers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="247">
-    <td><a href="http://wg21.link/cwg247">247</a></td>
+    <td><a href="https://wg21.link/cwg247">247</a></td>
     <td>NAD</td>
     <td>Pointer-to-member casts and function overload resolution</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="248">
-    <td><a href="http://wg21.link/cwg248">248</a></td>
+    <td><a href="https://wg21.link/cwg248">248</a></td>
     <td>C++11</td>
     <td>Identifier characters</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="249">
-    <td><a href="http://wg21.link/cwg249">249</a></td>
+    <td><a href="https://wg21.link/cwg249">249</a></td>
     <td>TC1</td>
     <td>What is a member function template?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="250">
-    <td><a href="http://wg21.link/cwg250">250</a></td>
+    <td><a href="https://wg21.link/cwg250">250</a></td>
     <td>TC1</td>
     <td>Address of function template specialization with non-deduced template arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="251">
-    <td><a href="http://wg21.link/cwg251">251</a></td>
+    <td><a href="https://wg21.link/cwg251">251</a></td>
     <td>open</td>
     <td>How many signed integer types are there?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="252">
-    <td><a href="http://wg21.link/cwg252">252</a></td>
+    <td><a href="https://wg21.link/cwg252">252</a></td>
     <td>CD1</td>
     <td>Looking up deallocation functions in virtual destructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="253">
-    <td><a href="http://wg21.link/cwg253">253</a></td>
+    <td><a href="https://wg21.link/cwg253">253</a></td>
     <td>C++17</td>
     <td>Why must empty or fully-initialized const objects be initialized?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="254">
-    <td><a href="http://wg21.link/cwg254">254</a></td>
+    <td><a href="https://wg21.link/cwg254">254</a></td>
     <td>CD1</td>
     <td>Definitional problems with <I>elaborated-type-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="255">
-    <td><a href="http://wg21.link/cwg255">255</a></td>
+    <td><a href="https://wg21.link/cwg255">255</a></td>
     <td>drafting</td>
     <td>Placement deallocation functions and lookup ambiguity</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="256">
-    <td><a href="http://wg21.link/cwg256">256</a></td>
+    <td><a href="https://wg21.link/cwg256">256</a></td>
     <td>CD1</td>
     <td>Overflow in size calculations</td>
     <td class="none" align="center">Duplicate of <a href="#624">624</a></td>
   </tr>
   <tr id="257">
-    <td><a href="http://wg21.link/cwg257">257</a></td>
+    <td><a href="https://wg21.link/cwg257">257</a></td>
     <td>CD2</td>
     <td>Abstract base constructors and virtual base initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="258">
-    <td><a href="http://wg21.link/cwg258">258</a></td>
+    <td><a href="https://wg21.link/cwg258">258</a></td>
     <td>CD1</td>
     <td><I>using-declaration</I>s and cv-qualifiers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="259">
-    <td><a href="http://wg21.link/cwg259">259</a></td>
+    <td><a href="https://wg21.link/cwg259">259</a></td>
     <td>CD1</td>
     <td>Restrictions on explicit specialization and instantiation</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr class="open" id="260">
-    <td><a href="http://wg21.link/cwg260">260</a></td>
+    <td><a href="https://wg21.link/cwg260">260</a></td>
     <td>open</td>
     <td>User-defined conversions and built-in <TT>operator=</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="261">
-    <td><a href="http://wg21.link/cwg261">261</a></td>
+    <td><a href="https://wg21.link/cwg261">261</a></td>
     <td>CD1</td>
     <td>When is a deallocation function "used?"</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="262">
-    <td><a href="http://wg21.link/cwg262">262</a></td>
+    <td><a href="https://wg21.link/cwg262">262</a></td>
     <td>CD1</td>
     <td>Default arguments and ellipsis</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="263">
-    <td><a href="http://wg21.link/cwg263">263</a></td>
+    <td><a href="https://wg21.link/cwg263">263</a></td>
     <td>CD1</td>
     <td>Can a constructor be declared a friend?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="264">
-    <td><a href="http://wg21.link/cwg264">264</a></td>
+    <td><a href="https://wg21.link/cwg264">264</a></td>
     <td>open</td>
     <td>Unusable template constructors and conversion functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="265">
-    <td><a href="http://wg21.link/cwg265">265</a></td>
+    <td><a href="https://wg21.link/cwg265">265</a></td>
     <td>dup</td>
     <td>Destructors, exceptions, and deallocation</td>
     <td class="none" align="center">Duplicate of <a href="#353">353</a></td>
   </tr>
   <tr id="266">
-    <td><a href="http://wg21.link/cwg266">266</a></td>
+    <td><a href="https://wg21.link/cwg266">266</a></td>
     <td>NAD</td>
     <td>No grammar sentence symbol</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="267">
-    <td><a href="http://wg21.link/cwg267">267</a></td>
+    <td><a href="https://wg21.link/cwg267">267</a></td>
     <td>open</td>
     <td>Alignment requirement for <I>new-expression</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="268">
-    <td><a href="http://wg21.link/cwg268">268</a></td>
+    <td><a href="https://wg21.link/cwg268">268</a></td>
     <td>open</td>
     <td>Macro name suppression in rescanned replacement text</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="269">
-    <td><a href="http://wg21.link/cwg269">269</a></td>
+    <td><a href="https://wg21.link/cwg269">269</a></td>
     <td>NAD</td>
-    <td>Order of initialization of multiply-defined static data members
+    <td>Order of initialization of multiply-defined static data members
 of class templates</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="270">
-    <td><a href="http://wg21.link/cwg270">270</a></td>
+    <td><a href="https://wg21.link/cwg270">270</a></td>
     <td>CD1</td>
     <td>Order of initialization of static data members of class templates</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="271">
-    <td><a href="http://wg21.link/cwg271">271</a></td>
+    <td><a href="https://wg21.link/cwg271">271</a></td>
     <td>open</td>
     <td>Explicit instantiation and template argument deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="272">
-    <td><a href="http://wg21.link/cwg272">272</a></td>
+    <td><a href="https://wg21.link/cwg272">272</a></td>
     <td>CD1</td>
     <td>Explicit destructor invocation and <I>qualified-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="273">
-    <td><a href="http://wg21.link/cwg273">273</a></td>
+    <td><a href="https://wg21.link/cwg273">273</a></td>
     <td>CD1</td>
     <td>POD classes and <TT>operator&amp;()</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="274">
-    <td><a href="http://wg21.link/cwg274">274</a></td>
+    <td><a href="https://wg21.link/cwg274">274</a></td>
     <td>CD1</td>
     <td>Cv-qualification and char-alias access to out-of-lifetime objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="275">
-    <td><a href="http://wg21.link/cwg275">275</a></td>
+    <td><a href="https://wg21.link/cwg275">275</a></td>
     <td>CD1</td>
     <td>Explicit instantiation/specialization and <I>using-directive</I>s</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="276">
-    <td><a href="http://wg21.link/cwg276">276</a></td>
+    <td><a href="https://wg21.link/cwg276">276</a></td>
     <td>CD1</td>
     <td>Order of destruction of parameters and temporaries</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="277">
-    <td><a href="http://wg21.link/cwg277">277</a></td>
+    <td><a href="https://wg21.link/cwg277">277</a></td>
     <td>CD1</td>
     <td>Zero-initialization of pointers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="278">
-    <td><a href="http://wg21.link/cwg278">278</a></td>
+    <td><a href="https://wg21.link/cwg278">278</a></td>
     <td>open</td>
     <td>External linkage and nameless entities</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="279">
-    <td><a href="http://wg21.link/cwg279">279</a></td>
+    <td><a href="https://wg21.link/cwg279">279</a></td>
     <td>open</td>
     <td>Correspondence of "names for linkage purposes"</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="280">
-    <td><a href="http://wg21.link/cwg280">280</a></td>
+    <td><a href="https://wg21.link/cwg280">280</a></td>
     <td>CD1</td>
     <td>Access and surrogate call functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="281">
-    <td><a href="http://wg21.link/cwg281">281</a></td>
+    <td><a href="https://wg21.link/cwg281">281</a></td>
     <td>CD1</td>
     <td><TT>inline</TT> specifier in <TT>friend</TT> declarations</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="282">
-    <td><a href="http://wg21.link/cwg282">282</a></td>
+    <td><a href="https://wg21.link/cwg282">282</a></td>
     <td>open</td>
     <td>Namespace for <TT>extended_type_info</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="283">
-    <td><a href="http://wg21.link/cwg283">283</a></td>
+    <td><a href="https://wg21.link/cwg283">283</a></td>
     <td>CD1</td>
     <td>Template <I>type-parameter</I>s are not syntactically <I>type-name</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="284">
-    <td><a href="http://wg21.link/cwg284">284</a></td>
+    <td><a href="https://wg21.link/cwg284">284</a></td>
     <td>CD1</td>
     <td><I>qualified-id</I>s in class declarations</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="285">
-    <td><a href="http://wg21.link/cwg285">285</a></td>
+    <td><a href="https://wg21.link/cwg285">285</a></td>
     <td>NAD</td>
     <td>Identifying a function template being specialized</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="286">
-    <td><a href="http://wg21.link/cwg286">286</a></td>
+    <td><a href="https://wg21.link/cwg286">286</a></td>
     <td>CD1</td>
     <td>Incorrect example in partial specialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="287">
-    <td><a href="http://wg21.link/cwg287">287</a></td>
+    <td><a href="https://wg21.link/cwg287">287</a></td>
     <td>drafting</td>
     <td>Order dependencies in template instantiation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="288">
-    <td><a href="http://wg21.link/cwg288">288</a></td>
+    <td><a href="https://wg21.link/cwg288">288</a></td>
     <td>CD1</td>
     <td>Misuse of "static type" in describing pointers</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="289">
-    <td><a href="http://wg21.link/cwg289">289</a></td>
+    <td><a href="https://wg21.link/cwg289">289</a></td>
     <td>CD1</td>
     <td>Incomplete list of contexts requiring a complete type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="290">
-    <td><a href="http://wg21.link/cwg290">290</a></td>
+    <td><a href="https://wg21.link/cwg290">290</a></td>
     <td>NAD</td>
     <td>Should memcpy be allowed into a POD with a const member?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="291">
-    <td><a href="http://wg21.link/cwg291">291</a></td>
+    <td><a href="https://wg21.link/cwg291">291</a></td>
     <td>CD1</td>
     <td>Overload resolution needed when binding reference to class rvalue</td>
     <td class="full" align="center">Duplicate of <a href="#391">391</a></td>
   </tr>
   <tr id="292">
-    <td><a href="http://wg21.link/cwg292">292</a></td>
+    <td><a href="https://wg21.link/cwg292">292</a></td>
     <td>CD3</td>
     <td>Deallocation on exception in <TT>new</TT> before arguments evaluated</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="293">
-    <td><a href="http://wg21.link/cwg293">293</a></td>
+    <td><a href="https://wg21.link/cwg293">293</a></td>
     <td>open</td>
     <td>Syntax of explicit instantiation/specialization too permissive</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="294">
-    <td><a href="http://wg21.link/cwg294">294</a></td>
+    <td><a href="https://wg21.link/cwg294">294</a></td>
     <td>NAD</td>
     <td>Can <TT>static_cast</TT> drop exception specifications?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="295">
-    <td><a href="http://wg21.link/cwg295">295</a></td>
+    <td><a href="https://wg21.link/cwg295">295</a></td>
     <td>CD1</td>
     <td>cv-qualifiers on function types</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="296">
-    <td><a href="http://wg21.link/cwg296">296</a></td>
+    <td><a href="https://wg21.link/cwg296">296</a></td>
     <td>CD1</td>
     <td>Can conversion functions be static?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="297">
-    <td><a href="http://wg21.link/cwg297">297</a></td>
+    <td><a href="https://wg21.link/cwg297">297</a></td>
     <td>open</td>
     <td>Which template does an explicit specialization specialize?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="298">
-    <td><a href="http://wg21.link/cwg298">298</a></td>
+    <td><a href="https://wg21.link/cwg298">298</a></td>
     <td>CD1</td>
     <td><TT>T::x</TT> when <TT>T</TT> is cv-qualified</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="299">
-    <td><a href="http://wg21.link/cwg299">299</a></td>
+    <td><a href="https://wg21.link/cwg299">299</a></td>
     <td>CD1</td>
     <td>Conversion on array bound expression in <TT>new</TT></td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="300">
-    <td><a href="http://wg21.link/cwg300">300</a></td>
+    <td><a href="https://wg21.link/cwg300">300</a></td>
     <td>CD1</td>
     <td>References to functions in template argument deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="301">
-    <td><a href="http://wg21.link/cwg301">301</a></td>
+    <td><a href="https://wg21.link/cwg301">301</a></td>
     <td>CD1</td>
     <td>Syntax for <I>template-name</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="302">
-    <td><a href="http://wg21.link/cwg302">302</a></td>
+    <td><a href="https://wg21.link/cwg302">302</a></td>
     <td>CD1</td>
     <td>Value-initialization and generation of default constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="303">
-    <td><a href="http://wg21.link/cwg303">303</a></td>
+    <td><a href="https://wg21.link/cwg303">303</a></td>
     <td>NAD</td>
     <td>Integral promotions on bit-fields</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="304">
-    <td><a href="http://wg21.link/cwg304">304</a></td>
+    <td><a href="https://wg21.link/cwg304">304</a></td>
     <td>TC1</td>
     <td>Value-initialization of a reference</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="305">
-    <td><a href="http://wg21.link/cwg305">305</a></td>
+    <td><a href="https://wg21.link/cwg305">305</a></td>
     <td>CD1</td>
     <td>Name lookup in destructor call</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="306">
-    <td><a href="http://wg21.link/cwg306">306</a></td>
+    <td><a href="https://wg21.link/cwg306">306</a></td>
     <td>CD1</td>
     <td>Ambiguity by class name injection</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="307">
-    <td><a href="http://wg21.link/cwg307">307</a></td>
+    <td><a href="https://wg21.link/cwg307">307</a></td>
     <td>NAD</td>
     <td>Initialization of a virtual base class subobject</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="308">
-    <td><a href="http://wg21.link/cwg308">308</a></td>
+    <td><a href="https://wg21.link/cwg308">308</a></td>
     <td>NAD</td>
     <td>Catching exceptions with ambiguous base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="309">
-    <td><a href="http://wg21.link/cwg309">309</a></td>
+    <td><a href="https://wg21.link/cwg309">309</a></td>
     <td>CD1</td>
     <td>Linkage of entities whose names are not simply identifiers, in introduction</td>
     <td class="full" align="center">Duplicate of <a href="#485">485</a></td>
   </tr>
   <tr class="open" id="310">
-    <td><a href="http://wg21.link/cwg310">310</a></td>
+    <td><a href="https://wg21.link/cwg310">310</a></td>
     <td>open</td>
     <td>Can function templates differing only in parameter cv-qualifiers be overloaded?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="311">
-    <td><a href="http://wg21.link/cwg311">311</a></td>
+    <td><a href="https://wg21.link/cwg311">311</a></td>
     <td>NAD</td>
     <td>Using qualified name to reopen nested namespace</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="312">
-    <td><a href="http://wg21.link/cwg312">312</a></td>
+    <td><a href="https://wg21.link/cwg312">312</a></td>
     <td>CD3</td>
     <td>&#8220;use&#8221; of invalid pointer value not defined</td>
     <td class="full" align="center">Duplicate of <a href="#616">616</a></td>
   </tr>
   <tr id="313">
-    <td><a href="http://wg21.link/cwg313">313</a></td>
+    <td><a href="https://wg21.link/cwg313">313</a></td>
     <td>dup</td>
     <td>Class with single conversion function to integral as array size in <TT>new</TT></td>
     <td class="full" align="center">Duplicate of <a href="#299">299</a> (C++11 onwards)</td>
   </tr>
   <tr id="314">
-    <td><a href="http://wg21.link/cwg314">314</a></td>
+    <td><a href="https://wg21.link/cwg314">314</a></td>
     <td>C++17</td>
     <td><TT>template</TT> in base class specifier</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="315">
-    <td><a href="http://wg21.link/cwg315">315</a></td>
+    <td><a href="https://wg21.link/cwg315">315</a></td>
     <td>NAD</td>
     <td>Is call of static member function through null pointer undefined?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="316">
-    <td><a href="http://wg21.link/cwg316">316</a></td>
+    <td><a href="https://wg21.link/cwg316">316</a></td>
     <td>NAD</td>
     <td>Injected-class-name of template used as template template parameter</td>
     <td class="full" align="center">Superseded by <a href="#1004">1004</a></td>
   </tr>
   <tr id="317">
-    <td><a href="http://wg21.link/cwg317">317</a></td>
+    <td><a href="https://wg21.link/cwg317">317</a></td>
     <td>CD1</td>
     <td>Can a function be declared inline after it has been called?</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="318">
-    <td><a href="http://wg21.link/cwg318">318</a></td>
+    <td><a href="https://wg21.link/cwg318">318</a></td>
     <td>CD1</td>
     <td><TT>struct A::A</TT> should not name the constructor of <TT>A</TT></td>
     <td class="full" align="center">Superseded by <a href="#1310">1310</a></td>
   </tr>
   <tr id="319">
-    <td><a href="http://wg21.link/cwg319">319</a></td>
+    <td><a href="https://wg21.link/cwg319">319</a></td>
     <td>CD1</td>
     <td>Use of names without linkage in declaring entities with linkage</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="320">
-    <td><a href="http://wg21.link/cwg320">320</a></td>
+    <td><a href="https://wg21.link/cwg320">320</a></td>
     <td>CD1</td>
     <td>Question on copy constructor elision example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="321">
-    <td><a href="http://wg21.link/cwg321">321</a></td>
+    <td><a href="https://wg21.link/cwg321">321</a></td>
     <td>dup</td>
     <td>Associated classes and namespaces for argument-dependent lookup</td>
     <td class="full" align="center">Duplicate of <a href="#557">557</a></td>
   </tr>
   <tr id="322">
-    <td><a href="http://wg21.link/cwg322">322</a></td>
+    <td><a href="https://wg21.link/cwg322">322</a></td>
     <td>CD1</td>
     <td>Deduction of reference conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="323">
-    <td><a href="http://wg21.link/cwg323">323</a></td>
+    <td><a href="https://wg21.link/cwg323">323</a></td>
     <td>CD1</td>
     <td>Where must <TT>export</TT> appear?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="324">
-    <td><a href="http://wg21.link/cwg324">324</a></td>
+    <td><a href="https://wg21.link/cwg324">324</a></td>
     <td>CD1</td>
     <td>Can "<TT>&amp;</TT>" be applied to assignment to bit-field?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="325">
-    <td><a href="http://wg21.link/cwg325">325</a></td>
+    <td><a href="https://wg21.link/cwg325">325</a></td>
     <td>drafting</td>
     <td>When are default arguments parsed?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="326">
-    <td><a href="http://wg21.link/cwg326">326</a></td>
+    <td><a href="https://wg21.link/cwg326">326</a></td>
     <td>CD1</td>
     <td>Wording for definition of trivial constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="327">
-    <td><a href="http://wg21.link/cwg327">327</a></td>
+    <td><a href="https://wg21.link/cwg327">327</a></td>
     <td>CD1</td>
     <td>Use of "structure" without definition</td>
     <td class="na" align="center">Duplicate of <a href="#538">538</a></td>
   </tr>
   <tr id="328">
-    <td><a href="http://wg21.link/cwg328">328</a></td>
+    <td><a href="https://wg21.link/cwg328">328</a></td>
     <td>CD1</td>
     <td>Missing requirement that class member types be complete</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="329">
-    <td><a href="http://wg21.link/cwg329">329</a></td>
+    <td><a href="https://wg21.link/cwg329">329</a></td>
     <td>CD1</td>
     <td>Evaluation of friends of templates</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="330">
-    <td><a href="http://wg21.link/cwg330">330</a></td>
+    <td><a href="https://wg21.link/cwg330">330</a></td>
     <td>CD4</td>
     <td>Qualification conversions and pointers to arrays of pointers</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="331">
-    <td><a href="http://wg21.link/cwg331">331</a></td>
+    <td><a href="https://wg21.link/cwg331">331</a></td>
     <td>CD1</td>
     <td>Allowed copy constructor signatures</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="332">
-    <td><a href="http://wg21.link/cwg332">332</a></td>
+    <td><a href="https://wg21.link/cwg332">332</a></td>
     <td>CD3</td>
     <td>cv-qualified <TT>void</TT> parameter types</td>
     <td class="full" align="center">Duplicate of <a href="#577">577</a></td>
   </tr>
   <tr id="333">
-    <td><a href="http://wg21.link/cwg333">333</a></td>
+    <td><a href="https://wg21.link/cwg333">333</a></td>
     <td>NAD</td>
     <td>Ambiguous use of "declaration" in disambiguation section</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="334">
-    <td><a href="http://wg21.link/cwg334">334</a></td>
+    <td><a href="https://wg21.link/cwg334">334</a></td>
     <td>NAD</td>
     <td>Is a comma-expression dependent if its first operand is?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="335">
-    <td><a href="http://wg21.link/cwg335">335</a></td>
+    <td><a href="https://wg21.link/cwg335">335</a></td>
     <td>CD1</td>
     <td>Allowing <TT>export</TT> on template members of nontemplate classes</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="336">
-    <td><a href="http://wg21.link/cwg336">336</a></td>
+    <td><a href="https://wg21.link/cwg336">336</a></td>
     <td>CD1</td>
     <td>Explicit specialization examples are still incorrect</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="337">
-    <td><a href="http://wg21.link/cwg337">337</a></td>
+    <td><a href="https://wg21.link/cwg337">337</a></td>
     <td>CD1</td>
     <td>Attempt to create array of abtract type should cause deduction to fail</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="338">
-    <td><a href="http://wg21.link/cwg338">338</a></td>
+    <td><a href="https://wg21.link/cwg338">338</a></td>
     <td>open</td>
     <td>Enumerator name with linkage used as class name in other translation unit</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="339">
-    <td><a href="http://wg21.link/cwg339">339</a></td>
+    <td><a href="https://wg21.link/cwg339">339</a></td>
     <td>CD1</td>
     <td>Overload resolution in operand of <TT>sizeof</TT> in constant expression</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="340">
-    <td><a href="http://wg21.link/cwg340">340</a></td>
+    <td><a href="https://wg21.link/cwg340">340</a></td>
     <td>NAD</td>
     <td>Unclear wording in disambiguation section</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="341">
-    <td><a href="http://wg21.link/cwg341">341</a></td>
+    <td><a href="https://wg21.link/cwg341">341</a></td>
     <td>C++11</td>
     <td><TT>extern "C"</TT> namespace member function versus global variable</td>
     <td class="none" align="center">Superseded by <a href="#1708">1708</a></td>
   </tr>
   <tr id="342">
-    <td><a href="http://wg21.link/cwg342">342</a></td>
+    <td><a href="https://wg21.link/cwg342">342</a></td>
     <td>CD3</td>
     <td>Terminology: "indirection" versus "dereference"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="343">
-    <td><a href="http://wg21.link/cwg343">343</a></td>
+    <td><a href="https://wg21.link/cwg343">343</a></td>
     <td>C++17</td>
     <td>Make <TT>template</TT> optional in contexts that require a type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="344">
-    <td><a href="http://wg21.link/cwg344">344</a></td>
+    <td><a href="https://wg21.link/cwg344">344</a></td>
     <td>CD3</td>
     <td>Naming destructors</td>
     <td class="none" align="center">Duplicate of <a href="#1435">1435</a></td>
   </tr>
   <tr id="345">
-    <td><a href="http://wg21.link/cwg345">345</a></td>
+    <td><a href="https://wg21.link/cwg345">345</a></td>
     <td>CD1</td>
     <td>Misleading comment on example in templates chapter</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="346">
-    <td><a href="http://wg21.link/cwg346">346</a></td>
+    <td><a href="https://wg21.link/cwg346">346</a></td>
     <td>NAD</td>
     <td>Typo in 15.4</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="347">
-    <td><a href="http://wg21.link/cwg347">347</a></td>
+    <td><a href="https://wg21.link/cwg347">347</a></td>
     <td>NAD</td>
     <td>Use of derived class name in defining base class nested class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="348">
-    <td><a href="http://wg21.link/cwg348">348</a></td>
+    <td><a href="https://wg21.link/cwg348">348</a></td>
     <td>CD1</td>
     <td><TT>delete</TT> and user-written deallocation functions</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="349">
-    <td><a href="http://wg21.link/cwg349">349</a></td>
+    <td><a href="https://wg21.link/cwg349">349</a></td>
     <td>CD1</td>
     <td>Template argument deduction for conversion functions and qualification conversions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="350">
-    <td><a href="http://wg21.link/cwg350">350</a></td>
+    <td><a href="https://wg21.link/cwg350">350</a></td>
     <td>open</td>
     <td><TT>signed char</TT> underlying representation for objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="351">
-    <td><a href="http://wg21.link/cwg351">351</a></td>
+    <td><a href="https://wg21.link/cwg351">351</a></td>
     <td>CD1</td>
     <td>Sequence point error: unspecified or undefined?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="352">
-    <td><a href="http://wg21.link/cwg352">352</a></td>
+    <td><a href="https://wg21.link/cwg352">352</a></td>
     <td>CD1</td>
     <td>Nondeduced contexts</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="353">
-    <td><a href="http://wg21.link/cwg353">353</a></td>
+    <td><a href="https://wg21.link/cwg353">353</a></td>
     <td>CD1</td>
     <td>Is deallocation routine called if destructor throws exception in delete?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="354">
-    <td><a href="http://wg21.link/cwg354">354</a></td>
+    <td><a href="https://wg21.link/cwg354">354</a></td>
     <td>CD1</td>
     <td>Null as nontype template argument</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="355">
-    <td><a href="http://wg21.link/cwg355">355</a></td>
+    <td><a href="https://wg21.link/cwg355">355</a></td>
     <td>C++11</td>
     <td>Global-scope <TT>::</TT> in <I>nested-name-specifier</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="356">
-    <td><a href="http://wg21.link/cwg356">356</a></td>
+    <td><a href="https://wg21.link/cwg356">356</a></td>
     <td>NAD</td>
     <td>Wording of behavior of generated copy constructor for scalar members</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="357">
-    <td><a href="http://wg21.link/cwg357">357</a></td>
+    <td><a href="https://wg21.link/cwg357">357</a></td>
     <td>CD1</td>
     <td>Definition of signature should include name</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="358">
-    <td><a href="http://wg21.link/cwg358">358</a></td>
+    <td><a href="https://wg21.link/cwg358">358</a></td>
     <td>NAD</td>
     <td>Namespaces and extern "C"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="359">
-    <td><a href="http://wg21.link/cwg359">359</a></td>
+    <td><a href="https://wg21.link/cwg359">359</a></td>
     <td>NAD</td>
     <td>Type definition in anonymous union</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="360">
-    <td><a href="http://wg21.link/cwg360">360</a></td>
+    <td><a href="https://wg21.link/cwg360">360</a></td>
     <td>open</td>
     <td>Using-declaration that reduces access</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="361">
-    <td><a href="http://wg21.link/cwg361">361</a></td>
+    <td><a href="https://wg21.link/cwg361">361</a></td>
     <td>open</td>
     <td>Forward reference to default argument</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="362">
-    <td><a href="http://wg21.link/cwg362">362</a></td>
+    <td><a href="https://wg21.link/cwg362">362</a></td>
     <td>CD1</td>
     <td>Order of initialization in instantiation units</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="363">
-    <td><a href="http://wg21.link/cwg363">363</a></td>
+    <td><a href="https://wg21.link/cwg363">363</a></td>
     <td>NAD</td>
     <td>Initialization of class from self</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="364">
-    <td><a href="http://wg21.link/cwg364">364</a></td>
+    <td><a href="https://wg21.link/cwg364">364</a></td>
     <td>CD1</td>
     <td>Calling overloaded function with static in set, with no object</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="365">
-    <td><a href="http://wg21.link/cwg365">365</a></td>
+    <td><a href="https://wg21.link/cwg365">365</a></td>
     <td>open</td>
     <td>Storage duration and temporaries</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="366">
-    <td><a href="http://wg21.link/cwg366">366</a></td>
+    <td><a href="https://wg21.link/cwg366">366</a></td>
     <td>CD1</td>
     <td>String literal allowed in integral constant expression?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="367">
-    <td><a href="http://wg21.link/cwg367">367</a></td>
+    <td><a href="https://wg21.link/cwg367">367</a></td>
     <td>CD1</td>
     <td><TT>throw</TT> operator allowed in constant expression?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="368">
-    <td><a href="http://wg21.link/cwg368">368</a></td>
+    <td><a href="https://wg21.link/cwg368">368</a></td>
     <td>CD1</td>
     <td>Uses of non-type parameters that should cause deduction to fail</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="369">
-    <td><a href="http://wg21.link/cwg369">369</a></td>
+    <td><a href="https://wg21.link/cwg369">369</a></td>
     <td>drafting</td>
     <td>Are <TT>new</TT>/<TT>delete</TT> identifiers or <I>preprocessing-op-or-punc</I>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="370">
-    <td><a href="http://wg21.link/cwg370">370</a></td>
+    <td><a href="https://wg21.link/cwg370">370</a></td>
     <td>CD1</td>
     <td>Can <TT>#include &lt;...&gt;</TT> form be used other than for standard C++ headers?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="371">
-    <td><a href="http://wg21.link/cwg371">371</a></td>
+    <td><a href="https://wg21.link/cwg371">371</a></td>
     <td>open</td>
     <td>Interleaving of constructor calls</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="372">
-    <td><a href="http://wg21.link/cwg372">372</a></td>
+    <td><a href="https://wg21.link/cwg372">372</a></td>
     <td>CD1</td>
     <td>Is access granted by base class specifiers available in following base class specifiers?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="373">
-    <td><a href="http://wg21.link/cwg373">373</a></td>
+    <td><a href="https://wg21.link/cwg373">373</a></td>
     <td>C++11</td>
     <td>Lookup on namespace qualified name in using-directive</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr id="374">
-    <td><a href="http://wg21.link/cwg374">374</a></td>
+    <td><a href="https://wg21.link/cwg374">374</a></td>
     <td>CD2</td>
     <td>Can explicit specialization outside namespace use qualified name?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="375">
-    <td><a href="http://wg21.link/cwg375">375</a></td>
+    <td><a href="https://wg21.link/cwg375">375</a></td>
     <td>dup</td>
     <td>Confusing example on lookup with <TT>typename</TT></td>
     <td class="full" align="center">Duplicate of <a href="#345">345</a></td>
   </tr>
   <tr id="376">
-    <td><a href="http://wg21.link/cwg376">376</a></td>
+    <td><a href="https://wg21.link/cwg376">376</a></td>
     <td>NAD</td>
     <td>Class "definition" versus class "declaration"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="377">
-    <td><a href="http://wg21.link/cwg377">377</a></td>
+    <td><a href="https://wg21.link/cwg377">377</a></td>
     <td>CD1</td>
     <td>Enum whose enumerators will not fit in any integral type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="378">
-    <td><a href="http://wg21.link/cwg378">378</a></td>
+    <td><a href="https://wg21.link/cwg378">378</a></td>
     <td>CD1</td>
     <td>Wording that says temporaries are declared</td>
     <td class="na" align="center">Duplicate of <a href="#276">276</a></td>
   </tr>
   <tr id="379">
-    <td><a href="http://wg21.link/cwg379">379</a></td>
+    <td><a href="https://wg21.link/cwg379">379</a></td>
     <td>CD1</td>
     <td>Change "class declaration" to "class definition"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="380">
-    <td><a href="http://wg21.link/cwg380">380</a></td>
+    <td><a href="https://wg21.link/cwg380">380</a></td>
     <td>open</td>
     <td>Definition of "ambiguous base class" missing</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="381">
-    <td><a href="http://wg21.link/cwg381">381</a></td>
+    <td><a href="https://wg21.link/cwg381">381</a></td>
     <td>CD1</td>
     <td>Incorrect example of base class member lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="382">
-    <td><a href="http://wg21.link/cwg382">382</a></td>
+    <td><a href="https://wg21.link/cwg382">382</a></td>
     <td>CD1</td>
     <td>Allow <TT>typename</TT> outside of templates</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="383">
-    <td><a href="http://wg21.link/cwg383">383</a></td>
+    <td><a href="https://wg21.link/cwg383">383</a></td>
     <td>CD1</td>
     <td>Is a class with a declared but not defined destructor a POD?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="384">
-    <td><a href="http://wg21.link/cwg384">384</a></td>
+    <td><a href="https://wg21.link/cwg384">384</a></td>
     <td>NAD</td>
     <td>Argument-dependent lookup and operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="385">
-    <td><a href="http://wg21.link/cwg385">385</a></td>
+    <td><a href="https://wg21.link/cwg385">385</a></td>
     <td>CD1</td>
     <td>How does protected member check of 11.5 interact with using-declarations?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="386">
-    <td><a href="http://wg21.link/cwg386">386</a></td>
+    <td><a href="https://wg21.link/cwg386">386</a></td>
     <td>drafting</td>
     <td>Friend declaration of name brought in by <I>using-declaration</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="387">
-    <td><a href="http://wg21.link/cwg387">387</a></td>
+    <td><a href="https://wg21.link/cwg387">387</a></td>
     <td>CD1</td>
     <td>Errors in example in 14.6.5</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="388">
-    <td><a href="http://wg21.link/cwg388">388</a></td>
+    <td><a href="https://wg21.link/cwg388">388</a></td>
     <td>CD3</td>
     <td>Catching base<TT>*&amp;</TT> from a throw of derived<TT>*</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="389">
-    <td><a href="http://wg21.link/cwg389">389</a></td>
+    <td><a href="https://wg21.link/cwg389">389</a></td>
     <td>CD1</td>
     <td>Unnamed types in entities with linkage</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="390">
-    <td><a href="http://wg21.link/cwg390">390</a></td>
+    <td><a href="https://wg21.link/cwg390">390</a></td>
     <td>CD1</td>
     <td>Pure virtual must be defined when implicitly called</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="391">
-    <td><a href="http://wg21.link/cwg391">391</a></td>
+    <td><a href="https://wg21.link/cwg391">391</a></td>
     <td>CD1</td>
     <td>Require direct binding of short-lived references to rvalues</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="392">
-    <td><a href="http://wg21.link/cwg392">392</a></td>
+    <td><a href="https://wg21.link/cwg392">392</a></td>
     <td>CD1</td>
     <td>Use of full expression lvalue before temporary destruction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="393">
-    <td><a href="http://wg21.link/cwg393">393</a></td>
+    <td><a href="https://wg21.link/cwg393">393</a></td>
     <td>CD4</td>
     <td>Pointer to array of unknown bound in template argument list in parameter</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="394">
-    <td><a href="http://wg21.link/cwg394">394</a></td>
+    <td><a href="https://wg21.link/cwg394">394</a></td>
     <td>CD1</td>
     <td><I>identifier-list</I> is never defined</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="395">
-    <td><a href="http://wg21.link/cwg395">395</a></td>
+    <td><a href="https://wg21.link/cwg395">395</a></td>
     <td>NAD</td>
     <td>Conversion operator template syntax</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="396">
-    <td><a href="http://wg21.link/cwg396">396</a></td>
+    <td><a href="https://wg21.link/cwg396">396</a></td>
     <td>CD1</td>
     <td>Misleading note regarding use of <TT>auto</TT> for disambiguation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="397">
-    <td><a href="http://wg21.link/cwg397">397</a></td>
+    <td><a href="https://wg21.link/cwg397">397</a></td>
     <td>CD1</td>
     <td>Same address for string literals from default arguments in inline functions?</td>
     <td class="none" align="center">Superseded by <a href="#1823">1823</a></td>
   </tr>
   <tr id="398">
-    <td><a href="http://wg21.link/cwg398">398</a></td>
+    <td><a href="https://wg21.link/cwg398">398</a></td>
     <td>CD1</td>
     <td>Ambiguous wording on naming a type in deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="399">
-    <td><a href="http://wg21.link/cwg399">399</a></td>
+    <td><a href="https://wg21.link/cwg399">399</a></td>
     <td>drafting</td>
     <td>Destructor lookup redux</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="400">
-    <td><a href="http://wg21.link/cwg400">400</a></td>
+    <td><a href="https://wg21.link/cwg400">400</a></td>
     <td>CD1</td>
     <td>Using-declarations and the "struct hack"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="401">
-    <td><a href="http://wg21.link/cwg401">401</a></td>
+    <td><a href="https://wg21.link/cwg401">401</a></td>
     <td>CD1</td>
     <td>When is access for template parameter default arguments checked?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="402">
-    <td><a href="http://wg21.link/cwg402">402</a></td>
+    <td><a href="https://wg21.link/cwg402">402</a></td>
     <td>open</td>
     <td>More on partial ordering of function templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="403">
-    <td><a href="http://wg21.link/cwg403">403</a></td>
+    <td><a href="https://wg21.link/cwg403">403</a></td>
     <td>CD1</td>
     <td>Reference to a type as a <I>template-id</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="404">
-    <td><a href="http://wg21.link/cwg404">404</a></td>
+    <td><a href="https://wg21.link/cwg404">404</a></td>
     <td>CD1</td>
     <td>Unclear reference to construction with non-trivial constructor</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="405">
-    <td><a href="http://wg21.link/cwg405">405</a></td>
+    <td><a href="https://wg21.link/cwg405">405</a></td>
     <td>open</td>
     <td>Unqualified function name lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="406">
-    <td><a href="http://wg21.link/cwg406">406</a></td>
+    <td><a href="https://wg21.link/cwg406">406</a></td>
     <td>CD1</td>
     <td>Static data member in class with name for linkage purposes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="407">
-    <td><a href="http://wg21.link/cwg407">407</a></td>
+    <td><a href="https://wg21.link/cwg407">407</a></td>
     <td>C++11</td>
     <td>Named class with associated typedef: two names or one?</td>
     <td class="full" align="center">Clang 3.8</td>
   </tr>
   <tr id="408">
-    <td><a href="http://wg21.link/cwg408">408</a></td>
+    <td><a href="https://wg21.link/cwg408">408</a></td>
     <td>CD2</td>
     <td>sizeof applied to unknown-bound array static data member of template</td>
     <td class="full" align="center">Clang 3.4</td>
   </tr>
   <tr id="409">
-    <td><a href="http://wg21.link/cwg409">409</a></td>
+    <td><a href="https://wg21.link/cwg409">409</a></td>
     <td>CD1</td>
     <td>Obsolete paragraph missed by changes for issue 224</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="410">
-    <td><a href="http://wg21.link/cwg410">410</a></td>
+    <td><a href="https://wg21.link/cwg410">410</a></td>
     <td>CD1</td>
     <td>Paragraph missed in changes for issue 166</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="411">
-    <td><a href="http://wg21.link/cwg411">411</a></td>
+    <td><a href="https://wg21.link/cwg411">411</a></td>
     <td>open</td>
     <td>Use of universal-character-name in character versus string literals</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="412">
-    <td><a href="http://wg21.link/cwg412">412</a></td>
+    <td><a href="https://wg21.link/cwg412">412</a></td>
     <td>NAD</td>
     <td>Can a replacement allocation function be inline?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="413">
-    <td><a href="http://wg21.link/cwg413">413</a></td>
+    <td><a href="https://wg21.link/cwg413">413</a></td>
     <td>CD1</td>
     <td>Definition of "empty class"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="414">
-    <td><a href="http://wg21.link/cwg414">414</a></td>
+    <td><a href="https://wg21.link/cwg414">414</a></td>
     <td>CD1</td>
     <td>Multiple types found on destructor lookup</td>
     <td class="none" align="center">Duplicate of <a href="#305">305</a></td>
   </tr>
   <tr id="415">
-    <td><a href="http://wg21.link/cwg415">415</a></td>
+    <td><a href="https://wg21.link/cwg415">415</a></td>
     <td>CD1</td>
     <td>Template deduction does not cause instantiation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="416">
-    <td><a href="http://wg21.link/cwg416">416</a></td>
+    <td><a href="https://wg21.link/cwg416">416</a></td>
     <td>CD1</td>
     <td>Class must be complete to allow operator lookup?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="417">
-    <td><a href="http://wg21.link/cwg417">417</a></td>
+    <td><a href="https://wg21.link/cwg417">417</a></td>
     <td>CD1</td>
     <td>Using derived-class qualified name in out-of-class nested class definition</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="418">
-    <td><a href="http://wg21.link/cwg418">418</a></td>
+    <td><a href="https://wg21.link/cwg418">418</a></td>
     <td>open</td>
     <td>Imperfect wording on error on multiple default arguments on a called function</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="419">
-    <td><a href="http://wg21.link/cwg419">419</a></td>
+    <td><a href="https://wg21.link/cwg419">419</a></td>
     <td>open</td>
     <td>Can cast to virtual base class be done on partially-constructed object?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="420">
-    <td><a href="http://wg21.link/cwg420">420</a></td>
+    <td><a href="https://wg21.link/cwg420">420</a></td>
     <td>CD1</td>
     <td>postfixexpression-&gt;scalar_type_dtor() inconsistent</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="421">
-    <td><a href="http://wg21.link/cwg421">421</a></td>
+    <td><a href="https://wg21.link/cwg421">421</a></td>
     <td>CD1</td>
     <td>Is rvalue.field an rvalue?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="422">
-    <td><a href="http://wg21.link/cwg422">422</a></td>
+    <td><a href="https://wg21.link/cwg422">422</a></td>
     <td>NAD</td>
     <td>Is a typedef redeclaration allowed with a template type that might be the same?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="423">
-    <td><a href="http://wg21.link/cwg423">423</a></td>
+    <td><a href="https://wg21.link/cwg423">423</a></td>
     <td>NAD</td>
     <td>Can a conversion be done on the left operand of a compound assignment?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="424">
-    <td><a href="http://wg21.link/cwg424">424</a></td>
+    <td><a href="https://wg21.link/cwg424">424</a></td>
     <td>CD1</td>
     <td>Wording problem with issue 56 resolution on redeclaring typedefs in class scope</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="425">
-    <td><a href="http://wg21.link/cwg425">425</a></td>
+    <td><a href="https://wg21.link/cwg425">425</a></td>
     <td>CD1</td>
     <td>Set of candidates for overloaded built-in operator with float operand</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="426">
-    <td><a href="http://wg21.link/cwg426">426</a></td>
+    <td><a href="https://wg21.link/cwg426">426</a></td>
     <td>C++17</td>
     <td>Identically-named variables, one internally and one externally linked, allowed?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="427">
-    <td><a href="http://wg21.link/cwg427">427</a></td>
+    <td><a href="https://wg21.link/cwg427">427</a></td>
     <td>CD1</td>
     <td><TT>static_cast</TT> ambiguity: conversion versus cast to derived</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="428">
-    <td><a href="http://wg21.link/cwg428">428</a></td>
+    <td><a href="https://wg21.link/cwg428">428</a></td>
     <td>CD1</td>
     <td>Mention of expression with reference type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="429">
-    <td><a href="http://wg21.link/cwg429">429</a></td>
+    <td><a href="https://wg21.link/cwg429">429</a></td>
     <td>CD1</td>
     <td>Matching deallocation function chosen based on syntax or signature?</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="430">
-    <td><a href="http://wg21.link/cwg430">430</a></td>
+    <td><a href="https://wg21.link/cwg430">430</a></td>
     <td>CD1</td>
     <td>Ordering of expression evaluation in initializer list</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="431">
-    <td><a href="http://wg21.link/cwg431">431</a></td>
+    <td><a href="https://wg21.link/cwg431">431</a></td>
     <td>C++11</td>
     <td>Defect in wording in 14.2</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="432">
-    <td><a href="http://wg21.link/cwg432">432</a></td>
+    <td><a href="https://wg21.link/cwg432">432</a></td>
     <td>CD1</td>
     <td>Is injected class name visible in base class specifier list?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="433">
-    <td><a href="http://wg21.link/cwg433">433</a></td>
+    <td><a href="https://wg21.link/cwg433">433</a></td>
     <td>CD1</td>
     <td>Do elaborated type specifiers in templates inject into enclosing namespace scope?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="434">
-    <td><a href="http://wg21.link/cwg434">434</a></td>
+    <td><a href="https://wg21.link/cwg434">434</a></td>
     <td>NAD</td>
     <td>Unclear suppression of standard conversions while binding reference to lvalue</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="435">
-    <td><a href="http://wg21.link/cwg435">435</a></td>
+    <td><a href="https://wg21.link/cwg435">435</a></td>
     <td>NAD</td>
     <td>Change "declararation or definition" to "declaration"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="436">
-    <td><a href="http://wg21.link/cwg436">436</a></td>
+    <td><a href="https://wg21.link/cwg436">436</a></td>
     <td>CD1</td>
     <td>Problem in example in 9.6 paragraph 4</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="437">
-    <td><a href="http://wg21.link/cwg437">437</a></td>
+    <td><a href="https://wg21.link/cwg437">437</a></td>
     <td>CD1</td>
     <td>Is type of class allowed in member function exception specification?</td>
     <td class="none" align="center">Superseded by <a href="#1308">1308</a></td>
   </tr>
   <tr id="438">
-    <td><a href="http://wg21.link/cwg438">438</a></td>
+    <td><a href="https://wg21.link/cwg438">438</a></td>
     <td>CD2</td>
     <td>Possible flaw in wording for multiple accesses to object between sequence points</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="439">
-    <td><a href="http://wg21.link/cwg439">439</a></td>
+    <td><a href="https://wg21.link/cwg439">439</a></td>
     <td>CD1</td>
     <td>Guarantees on casting pointer back to cv-qualified version of original type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="440">
-    <td><a href="http://wg21.link/cwg440">440</a></td>
+    <td><a href="https://wg21.link/cwg440">440</a></td>
     <td>open</td>
     <td>Allow implicit pointer-to-member conversion on nontype template argument</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="441">
-    <td><a href="http://wg21.link/cwg441">441</a></td>
+    <td><a href="https://wg21.link/cwg441">441</a></td>
     <td>CD1</td>
     <td>Ordering of static reference initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="442">
-    <td><a href="http://wg21.link/cwg442">442</a></td>
+    <td><a href="https://wg21.link/cwg442">442</a></td>
     <td>CD1</td>
     <td>Incorrect use of null pointer constant in description of delete operator</td>
     <td class="na" align="center">Superseded by <a href="#348">348</a></td>
   </tr>
   <tr id="443">
-    <td><a href="http://wg21.link/cwg443">443</a></td>
+    <td><a href="https://wg21.link/cwg443">443</a></td>
     <td>CD1</td>
     <td>Wording nit in description of lifetime of temporaries</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="444">
-    <td><a href="http://wg21.link/cwg444">444</a></td>
+    <td><a href="https://wg21.link/cwg444">444</a></td>
     <td>NAD</td>
     <td>Overriding and the generated copy assignment operator</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="445">
-    <td><a href="http://wg21.link/cwg445">445</a></td>
+    <td><a href="https://wg21.link/cwg445">445</a></td>
     <td>NAD</td>
     <td>Wording issue on friend declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="446">
-    <td><a href="http://wg21.link/cwg446">446</a></td>
+    <td><a href="https://wg21.link/cwg446">446</a></td>
     <td>CD1</td>
     <td>Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="447">
-    <td><a href="http://wg21.link/cwg447">447</a></td>
+    <td><a href="https://wg21.link/cwg447">447</a></td>
     <td>CD1</td>
     <td>Is offsetof type-dependent?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="448">
-    <td><a href="http://wg21.link/cwg448">448</a></td>
+    <td><a href="https://wg21.link/cwg448">448</a></td>
     <td>C++11</td>
     <td>Set of template functions in call with dependent explicit argument</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="449">
-    <td><a href="http://wg21.link/cwg449">449</a></td>
+    <td><a href="https://wg21.link/cwg449">449</a></td>
     <td>NAD</td>
     <td>Consistency in use of hyphen with names of "non" entities</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="450">
-    <td><a href="http://wg21.link/cwg450">450</a></td>
+    <td><a href="https://wg21.link/cwg450">450</a></td>
     <td>CD1</td>
     <td>Binding a reference to const to a cv-qualified array rvalue</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="451">
-    <td><a href="http://wg21.link/cwg451">451</a></td>
+    <td><a href="https://wg21.link/cwg451">451</a></td>
     <td>CD1</td>
     <td>Expressions with invalid results and ill-formedness</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="452">
-    <td><a href="http://wg21.link/cwg452">452</a></td>
+    <td><a href="https://wg21.link/cwg452">452</a></td>
     <td>CD1</td>
     <td>Wording nit on description of <TT>this</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="453">
-    <td><a href="http://wg21.link/cwg453">453</a></td>
+    <td><a href="https://wg21.link/cwg453">453</a></td>
     <td>drafting</td>
     <td>References may only bind to &#8220;valid&#8221; objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="454">
-    <td><a href="http://wg21.link/cwg454">454</a></td>
+    <td><a href="https://wg21.link/cwg454">454</a></td>
     <td>CD1</td>
     <td>When is a definition of a static data member required?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="455">
-    <td><a href="http://wg21.link/cwg455">455</a></td>
+    <td><a href="https://wg21.link/cwg455">455</a></td>
     <td>drafting</td>
     <td>Partial ordering and non-deduced arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="456">
-    <td><a href="http://wg21.link/cwg456">456</a></td>
+    <td><a href="https://wg21.link/cwg456">456</a></td>
     <td>NAD</td>
     <td>Is initialized const int or const bool variable a null pointer constant?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="457">
-    <td><a href="http://wg21.link/cwg457">457</a></td>
+    <td><a href="https://wg21.link/cwg457">457</a></td>
     <td>CD1</td>
     <td>Wording nit on use of const variables in constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="458">
-    <td><a href="http://wg21.link/cwg458">458</a></td>
+    <td><a href="https://wg21.link/cwg458">458</a></td>
     <td>C++11</td>
     <td>Hiding of member template parameters by other members</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="459">
-    <td><a href="http://wg21.link/cwg459">459</a></td>
+    <td><a href="https://wg21.link/cwg459">459</a></td>
     <td>open</td>
     <td>Hiding of template parameters by base class members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="460">
-    <td><a href="http://wg21.link/cwg460">460</a></td>
+    <td><a href="https://wg21.link/cwg460">460</a></td>
     <td>CD1</td>
     <td>Can a <I>using-declaration</I> name a namespace?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="461">
-    <td><a href="http://wg21.link/cwg461">461</a></td>
+    <td><a href="https://wg21.link/cwg461">461</a></td>
     <td>NAD</td>
     <td>Make <TT>asm</TT> conditionally-supported</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="462">
-    <td><a href="http://wg21.link/cwg462">462</a></td>
+    <td><a href="https://wg21.link/cwg462">462</a></td>
     <td>CD3</td>
     <td>Lifetime of temporaries bound to comma expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="463">
-    <td><a href="http://wg21.link/cwg463">463</a></td>
+    <td><a href="https://wg21.link/cwg463">463</a></td>
     <td>CD1</td>
     <td><TT>reinterpret_cast&lt;T*&gt;(0)</TT></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="464">
-    <td><a href="http://wg21.link/cwg464">464</a></td>
+    <td><a href="https://wg21.link/cwg464">464</a></td>
     <td>CD1</td>
     <td>Wording nit on lifetime of temporaries to which references are bound</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="465">
-    <td><a href="http://wg21.link/cwg465">465</a></td>
+    <td><a href="https://wg21.link/cwg465">465</a></td>
     <td>NAD</td>
     <td>May constructors of global objects call <TT>exit()</TT>?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="466">
-    <td><a href="http://wg21.link/cwg466">466</a></td>
+    <td><a href="https://wg21.link/cwg466">466</a></td>
     <td>CD1</td>
     <td>cv-qualifiers on pseudo-destructor type</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="467">
-    <td><a href="http://wg21.link/cwg467">467</a></td>
+    <td><a href="https://wg21.link/cwg467">467</a></td>
     <td>NAD</td>
     <td>Jump past initialization of local static variable</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="468">
-    <td><a href="http://wg21.link/cwg468">468</a></td>
+    <td><a href="https://wg21.link/cwg468">468</a></td>
     <td>CD1</td>
     <td>Allow <TT>::template</TT> outside of templates</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="469">
-    <td><a href="http://wg21.link/cwg469">469</a></td>
+    <td><a href="https://wg21.link/cwg469">469</a></td>
     <td>NAD</td>
     <td>Const template specializations and reference arguments</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="470">
-    <td><a href="http://wg21.link/cwg470">470</a></td>
+    <td><a href="https://wg21.link/cwg470">470</a></td>
     <td>CD1</td>
     <td>Instantiation of members of an explicitly-instantiated class template</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="471">
-    <td><a href="http://wg21.link/cwg471">471</a></td>
+    <td><a href="https://wg21.link/cwg471">471</a></td>
     <td>NAD</td>
     <td>Conflicting inherited access specifications</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="472">
-    <td><a href="http://wg21.link/cwg472">472</a></td>
+    <td><a href="https://wg21.link/cwg472">472</a></td>
     <td>drafting</td>
     <td>Casting across protected inheritance</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="473">
-    <td><a href="http://wg21.link/cwg473">473</a></td>
+    <td><a href="https://wg21.link/cwg473">473</a></td>
     <td>open</td>
     <td>Block-scope declarations of allocator functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="474">
-    <td><a href="http://wg21.link/cwg474">474</a></td>
+    <td><a href="https://wg21.link/cwg474">474</a></td>
     <td>CD1</td>
     <td>Block-scope <TT>extern</TT> declarations in namespace members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="475">
-    <td><a href="http://wg21.link/cwg475">475</a></td>
+    <td><a href="https://wg21.link/cwg475">475</a></td>
     <td>C++11</td>
     <td>When is <TT>std::uncaught_exception()</TT> true? (take 2)</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="476">
-    <td><a href="http://wg21.link/cwg476">476</a></td>
+    <td><a href="https://wg21.link/cwg476">476</a></td>
     <td>extension</td>
     <td>Determining the buffer size for placement new</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="477">
-    <td><a href="http://wg21.link/cwg477">477</a></td>
+    <td><a href="https://wg21.link/cwg477">477</a></td>
     <td>CD1</td>
     <td>Can <TT>virtual</TT> appear in a <TT>friend</TT> declaration?</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="478">
-    <td><a href="http://wg21.link/cwg478">478</a></td>
+    <td><a href="https://wg21.link/cwg478">478</a></td>
     <td>NAD</td>
     <td>May a function parameter be an array of an abstract class type?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="479">
-    <td><a href="http://wg21.link/cwg479">479</a></td>
+    <td><a href="https://wg21.link/cwg479">479</a></td>
     <td>CD1</td>
     <td>Copy elision in exception handling</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="480">
-    <td><a href="http://wg21.link/cwg480">480</a></td>
+    <td><a href="https://wg21.link/cwg480">480</a></td>
     <td>CD1</td>
     <td>Is a base of a virtual base also virtual?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="481">
-    <td><a href="http://wg21.link/cwg481">481</a></td>
+    <td><a href="https://wg21.link/cwg481">481</a></td>
     <td>CD2</td>
     <td>Scope of template parameters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="482">
-    <td><a href="http://wg21.link/cwg482">482</a></td>
+    <td><a href="https://wg21.link/cwg482">482</a></td>
     <td>CD3</td>
     <td>Qualified declarators in redeclarations</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="483">
-    <td><a href="http://wg21.link/cwg483">483</a></td>
+    <td><a href="https://wg21.link/cwg483">483</a></td>
     <td>CD3</td>
     <td>Normative requirements on integral ranges</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="484">
-    <td><a href="http://wg21.link/cwg484">484</a></td>
+    <td><a href="https://wg21.link/cwg484">484</a></td>
     <td>CD1</td>
     <td>Can a <I>base-specifier</I> name a cv-qualified class type?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="485">
-    <td><a href="http://wg21.link/cwg485">485</a></td>
+    <td><a href="https://wg21.link/cwg485">485</a></td>
     <td>CD1</td>
     <td>What is a &#8220;name&#8221;?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="486">
-    <td><a href="http://wg21.link/cwg486">486</a></td>
+    <td><a href="https://wg21.link/cwg486">486</a></td>
     <td>CD1</td>
     <td>Invalid return types and template argument deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="487">
-    <td><a href="http://wg21.link/cwg487">487</a></td>
+    <td><a href="https://wg21.link/cwg487">487</a></td>
     <td>NAD</td>
     <td>Operator overloading in constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="488">
-    <td><a href="http://wg21.link/cwg488">488</a></td>
+    <td><a href="https://wg21.link/cwg488">488</a></td>
     <td>CD1</td>
     <td>Local types, overload resolution, and template argument deduction</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="489">
-    <td><a href="http://wg21.link/cwg489">489</a></td>
+    <td><a href="https://wg21.link/cwg489">489</a></td>
     <td>NAD</td>
     <td>Must member function templates be instantiated during overload resolution?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="490">
-    <td><a href="http://wg21.link/cwg490">490</a></td>
+    <td><a href="https://wg21.link/cwg490">490</a></td>
     <td>CD2</td>
     <td>Name lookup in friend declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="491">
-    <td><a href="http://wg21.link/cwg491">491</a></td>
+    <td><a href="https://wg21.link/cwg491">491</a></td>
     <td>CD1</td>
     <td>Initializers for empty-class aggregrate members</td>
     <td class="full" align="center">Duplicate of <a href="#413">413</a></td>
   </tr>
   <tr id="492">
-    <td><a href="http://wg21.link/cwg492">492</a></td>
+    <td><a href="https://wg21.link/cwg492">492</a></td>
     <td>CD1</td>
     <td><TT>typeid</TT> constness inconsistent with example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="493">
-    <td><a href="http://wg21.link/cwg493">493</a></td>
+    <td><a href="https://wg21.link/cwg493">493</a></td>
     <td>CD2</td>
     <td>Type deduction from a <TT>bool</TT> context</td>
     <td class="none" align="center">Duplicate of <a href="#976">976</a></td>
   </tr>
   <tr id="494">
-    <td><a href="http://wg21.link/cwg494">494</a></td>
+    <td><a href="https://wg21.link/cwg494">494</a></td>
     <td>CD1</td>
     <td>Problems with the resolution of issue 45</td>
     <td class="none" align="center">Duplicate of <a href="#372">372</a></td>
   </tr>
   <tr id="495">
-    <td><a href="http://wg21.link/cwg495">495</a></td>
+    <td><a href="https://wg21.link/cwg495">495</a></td>
     <td>CD2</td>
     <td>Overload resolution with template and non-template conversion functions</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="496">
-    <td><a href="http://wg21.link/cwg496">496</a></td>
+    <td><a href="https://wg21.link/cwg496">496</a></td>
     <td>CD3</td>
     <td>Is a volatile-qualified type really a POD?</td>
     <td class="full" align="center">Superseded by <a href="#2094">2094</a></td>
   </tr>
   <tr id="497">
-    <td><a href="http://wg21.link/cwg497">497</a></td>
+    <td><a href="https://wg21.link/cwg497">497</a></td>
     <td>CD1</td>
     <td>Missing required initialization in example</td>
     <td class="none" align="center">Superseded by <a href="#253">253</a></td>
   </tr>
   <tr class="open" id="498">
-    <td><a href="http://wg21.link/cwg498">498</a></td>
+    <td><a href="https://wg21.link/cwg498">498</a></td>
     <td>open</td>
     <td>Storage class specifiers in definitions of class members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="499">
-    <td><a href="http://wg21.link/cwg499">499</a></td>
+    <td><a href="https://wg21.link/cwg499">499</a></td>
     <td>CD2</td>
     <td>Throwing an array of unknown size</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="500">
-    <td><a href="http://wg21.link/cwg500">500</a></td>
+    <td><a href="https://wg21.link/cwg500">500</a></td>
     <td>CD1</td>
     <td>Access in <I>base-specifier</I>s of friend and nested classes</td>
     <td class="none" align="center">Duplicate of <a href="#372">372</a></td>
   </tr>
   <tr id="501">
-    <td><a href="http://wg21.link/cwg501">501</a></td>
+    <td><a href="https://wg21.link/cwg501">501</a></td>
     <td>NAD</td>
     <td>Visibility of friend declarations within the befriending class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="502">
-    <td><a href="http://wg21.link/cwg502">502</a></td>
+    <td><a href="https://wg21.link/cwg502">502</a></td>
     <td>C++11</td>
     <td>Dependency of nested enumerations and enumerators</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="503">
-    <td><a href="http://wg21.link/cwg503">503</a></td>
+    <td><a href="https://wg21.link/cwg503">503</a></td>
     <td>open</td>
     <td>Cv-qualified function types in template argument deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="504">
-    <td><a href="http://wg21.link/cwg504">504</a></td>
+    <td><a href="https://wg21.link/cwg504">504</a></td>
     <td>open</td>
     <td>Should use of a variable in its own initializer require a diagnostic?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="505">
-    <td><a href="http://wg21.link/cwg505">505</a></td>
+    <td><a href="https://wg21.link/cwg505">505</a></td>
     <td>CD1</td>
     <td>Conditionally-supported behavior for unknown character escapes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="506">
-    <td><a href="http://wg21.link/cwg506">506</a></td>
+    <td><a href="https://wg21.link/cwg506">506</a></td>
     <td>CD1</td>
     <td>Conditionally-supported behavior for non-POD objects passed to ellipsis</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="507">
-    <td><a href="http://wg21.link/cwg507">507</a></td>
+    <td><a href="https://wg21.link/cwg507">507</a></td>
     <td>dup</td>
     <td>Ambiguity assigning class object to built-in type</td>
     <td class="none" align="center">Duplicate of <a href="#260">260</a></td>
   </tr>
   <tr id="508">
-    <td><a href="http://wg21.link/cwg508">508</a></td>
+    <td><a href="https://wg21.link/cwg508">508</a></td>
     <td>C++11</td>
     <td>Non-constructed value-initialized objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="509">
-    <td><a href="http://wg21.link/cwg509">509</a></td>
+    <td><a href="https://wg21.link/cwg509">509</a></td>
     <td>CD1</td>
     <td>Dead code in the specification of default initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="510">
-    <td><a href="http://wg21.link/cwg510">510</a></td>
+    <td><a href="https://wg21.link/cwg510">510</a></td>
     <td>CD1</td>
     <td>Default initialization of POD classes?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="511">
-    <td><a href="http://wg21.link/cwg511">511</a></td>
+    <td><a href="https://wg21.link/cwg511">511</a></td>
     <td>open</td>
     <td>POD-structs with template assignment operators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="512">
-    <td><a href="http://wg21.link/cwg512">512</a></td>
+    <td><a href="https://wg21.link/cwg512">512</a></td>
     <td>NAD</td>
     <td>Union members with user-declared non-default constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="513">
-    <td><a href="http://wg21.link/cwg513">513</a></td>
+    <td><a href="https://wg21.link/cwg513">513</a></td>
     <td>CD1</td>
     <td>Non-class &#8220;most-derived&#8221; objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="514">
-    <td><a href="http://wg21.link/cwg514">514</a></td>
+    <td><a href="https://wg21.link/cwg514">514</a></td>
     <td>CD1</td>
     <td>Is the initializer for a namespace member in the scope of the namespace?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="515">
-    <td><a href="http://wg21.link/cwg515">515</a></td>
+    <td><a href="https://wg21.link/cwg515">515</a></td>
     <td>CD1</td>
     <td>Non-dependent references to base class members</td>
     <td class="none" align="center">Superseded by <a href="#1017">1017</a></td>
   </tr>
   <tr id="516">
-    <td><a href="http://wg21.link/cwg516">516</a></td>
+    <td><a href="https://wg21.link/cwg516">516</a></td>
     <td>CD1</td>
     <td>Use of <TT>signed</TT> in bit-field declarations</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="517">
-    <td><a href="http://wg21.link/cwg517">517</a></td>
+    <td><a href="https://wg21.link/cwg517">517</a></td>
     <td>CD1</td>
     <td>Partial specialization following explicit instantiation</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="518">
-    <td><a href="http://wg21.link/cwg518">518</a></td>
+    <td><a href="https://wg21.link/cwg518">518</a></td>
     <td>CD1</td>
     <td>Trailing comma following <I>enumerator-list</I></td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="519">
-    <td><a href="http://wg21.link/cwg519">519</a></td>
+    <td><a href="https://wg21.link/cwg519">519</a></td>
     <td>CD1</td>
     <td>Null pointer preservation in <TT>void*</TT> conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="520">
-    <td><a href="http://wg21.link/cwg520">520</a></td>
+    <td><a href="https://wg21.link/cwg520">520</a></td>
     <td>CD1</td>
     <td>Old-style casts between incomplete class types</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="521">
-    <td><a href="http://wg21.link/cwg521">521</a></td>
+    <td><a href="https://wg21.link/cwg521">521</a></td>
     <td>CD1</td>
     <td>Requirements for exceptions thrown by allocation functions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="522">
-    <td><a href="http://wg21.link/cwg522">522</a></td>
+    <td><a href="https://wg21.link/cwg522">522</a></td>
     <td>CD1</td>
     <td>Array-to-pointer decay in template argument deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="523">
-    <td><a href="http://wg21.link/cwg523">523</a></td>
+    <td><a href="https://wg21.link/cwg523">523</a></td>
     <td>open</td>
     <td>Can a one-past-the-end pointer be invalidated by deleting an adjacent object?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="524">
-    <td><a href="http://wg21.link/cwg524">524</a></td>
+    <td><a href="https://wg21.link/cwg524">524</a></td>
     <td>CD1</td>
     <td>Can function-notation calls to operator functions be dependent?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="525">
-    <td><a href="http://wg21.link/cwg525">525</a></td>
+    <td><a href="https://wg21.link/cwg525">525</a></td>
     <td>CD1</td>
     <td>Missing <TT>*</TT> in example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="526">
-    <td><a href="http://wg21.link/cwg526">526</a></td>
+    <td><a href="https://wg21.link/cwg526">526</a></td>
     <td>CD1</td>
     <td>Confusing aspects in the specification of non-deduced contexts</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="527">
-    <td><a href="http://wg21.link/cwg527">527</a></td>
+    <td><a href="https://wg21.link/cwg527">527</a></td>
     <td>CD2</td>
     <td>Problems with linkage of types</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="528">
-    <td><a href="http://wg21.link/cwg528">528</a></td>
+    <td><a href="https://wg21.link/cwg528">528</a></td>
     <td>open</td>
     <td>Why are incomplete class types not allowed with <TT>typeid</TT>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="529">
-    <td><a href="http://wg21.link/cwg529">529</a></td>
+    <td><a href="https://wg21.link/cwg529">529</a></td>
     <td>drafting</td>
     <td>Use of <TT>template&lt;&gt;</TT> with &#8220;explicitly-specialized&#8221; class templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="530">
-    <td><a href="http://wg21.link/cwg530">530</a></td>
+    <td><a href="https://wg21.link/cwg530">530</a></td>
     <td>CD1</td>
     <td>Nontype template arguments in constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="531">
-    <td><a href="http://wg21.link/cwg531">531</a></td>
+    <td><a href="https://wg21.link/cwg531">531</a></td>
     <td>C++11</td>
     <td>Defining members of explicit specializations</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="532">
-    <td><a href="http://wg21.link/cwg532">532</a></td>
+    <td><a href="https://wg21.link/cwg532">532</a></td>
     <td>C++11</td>
     <td>Member/nonmember operator template partial ordering</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="533">
-    <td><a href="http://wg21.link/cwg533">533</a></td>
+    <td><a href="https://wg21.link/cwg533">533</a></td>
     <td>NAD</td>
     <td>Special treatment for C-style header names</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="534">
-    <td><a href="http://wg21.link/cwg534">534</a></td>
+    <td><a href="https://wg21.link/cwg534">534</a></td>
     <td>CD1</td>
     <td><I>template-name</I>s and <I>operator-function-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="535">
-    <td><a href="http://wg21.link/cwg535">535</a></td>
+    <td><a href="https://wg21.link/cwg535">535</a></td>
     <td>CD3</td>
     <td>Copy construction without a copy constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="536">
-    <td><a href="http://wg21.link/cwg536">536</a></td>
+    <td><a href="https://wg21.link/cwg536">536</a></td>
     <td>drafting</td>
     <td>Problems in the description of <I>id-expression</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="537">
-    <td><a href="http://wg21.link/cwg537">537</a></td>
+    <td><a href="https://wg21.link/cwg537">537</a></td>
     <td>CD1</td>
     <td>Definition of &#8220;signature&#8221;</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="538">
-    <td><a href="http://wg21.link/cwg538">538</a></td>
+    <td><a href="https://wg21.link/cwg538">538</a></td>
     <td>CD1</td>
-    <td>Definition and usage
-of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>,
+    <td>Definition and usage
+of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>,
 and <I>POD class</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="539">
-    <td><a href="http://wg21.link/cwg539">539</a></td>
+    <td><a href="https://wg21.link/cwg539">539</a></td>
     <td>CD3</td>
     <td>Constraints on <I>type-specifier-seq</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="540">
-    <td><a href="http://wg21.link/cwg540">540</a></td>
+    <td><a href="https://wg21.link/cwg540">540</a></td>
     <td>CD1</td>
     <td>Propagation of cv-qualifiers in reference-to-reference collapse</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="541">
-    <td><a href="http://wg21.link/cwg541">541</a></td>
+    <td><a href="https://wg21.link/cwg541">541</a></td>
     <td>CD2</td>
     <td>Dependent function types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="542">
-    <td><a href="http://wg21.link/cwg542">542</a></td>
+    <td><a href="https://wg21.link/cwg542">542</a></td>
     <td>CD2</td>
     <td>Value initialization of arrays of POD-structs</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="543">
-    <td><a href="http://wg21.link/cwg543">543</a></td>
+    <td><a href="https://wg21.link/cwg543">543</a></td>
     <td>CD1</td>
     <td>Value initialization and default constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="544">
-    <td><a href="http://wg21.link/cwg544">544</a></td>
+    <td><a href="https://wg21.link/cwg544">544</a></td>
     <td>NAD</td>
     <td>Base class lookup in explicit specialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="545">
-    <td><a href="http://wg21.link/cwg545">545</a></td>
+    <td><a href="https://wg21.link/cwg545">545</a></td>
     <td>open</td>
     <td>User-defined conversions and built-in operator overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="546">
-    <td><a href="http://wg21.link/cwg546">546</a></td>
+    <td><a href="https://wg21.link/cwg546">546</a></td>
     <td>C++11</td>
     <td>Explicit instantiation of class template members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="547">
-    <td><a href="http://wg21.link/cwg547">547</a></td>
+    <td><a href="https://wg21.link/cwg547">547</a></td>
     <td>C++11</td>
     <td>Partial specialization on member function types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="548">
-    <td><a href="http://wg21.link/cwg548">548</a></td>
+    <td><a href="https://wg21.link/cwg548">548</a></td>
     <td>dup</td>
     <td><I>qualified-id</I>s in declarations</td>
     <td class="full" align="center">Duplicate of <a href="#482">482</a></td>
   </tr>
   <tr class="open" id="549">
-    <td><a href="http://wg21.link/cwg549">549</a></td>
+    <td><a href="https://wg21.link/cwg549">549</a></td>
     <td>drafting</td>
     <td>Non-deducible parameters in partial specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="550">
-    <td><a href="http://wg21.link/cwg550">550</a></td>
+    <td><a href="https://wg21.link/cwg550">550</a></td>
     <td>dup</td>
     <td>Pointer to array of unknown bound in parameter declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="551">
-    <td><a href="http://wg21.link/cwg551">551</a></td>
+    <td><a href="https://wg21.link/cwg551">551</a></td>
     <td>CD1</td>
     <td>When is <TT>inline</TT> permitted in an explicit instantiation?</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="552">
-    <td><a href="http://wg21.link/cwg552">552</a></td>
+    <td><a href="https://wg21.link/cwg552">552</a></td>
     <td>NAD</td>
     <td>Use of <TT>typename</TT> in the type in a non-type <I>parameter-declaration</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="553">
-    <td><a href="http://wg21.link/cwg553">553</a></td>
+    <td><a href="https://wg21.link/cwg553">553</a></td>
     <td>NAD</td>
     <td>Problems with friend allocation and deallocation functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="554">
-    <td><a href="http://wg21.link/cwg554">554</a></td>
+    <td><a href="https://wg21.link/cwg554">554</a></td>
     <td>drafting</td>
     <td>Definition of &#8220;declarative region&#8221; and &#8220;scope&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="555">
-    <td><a href="http://wg21.link/cwg555">555</a></td>
+    <td><a href="https://wg21.link/cwg555">555</a></td>
     <td>drafting</td>
     <td>Pseudo-destructor name lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="556">
-    <td><a href="http://wg21.link/cwg556">556</a></td>
+    <td><a href="https://wg21.link/cwg556">556</a></td>
     <td>CD2</td>
     <td>Conflicting requirements for acceptable aliasing</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="557">
-    <td><a href="http://wg21.link/cwg557">557</a></td>
+    <td><a href="https://wg21.link/cwg557">557</a></td>
     <td>CD1</td>
     <td>Does argument-dependent lookup cause template instantiation?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="558">
-    <td><a href="http://wg21.link/cwg558">558</a></td>
+    <td><a href="https://wg21.link/cwg558">558</a></td>
     <td>CD1</td>
     <td>Excluded characters in universal character names</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="559">
-    <td><a href="http://wg21.link/cwg559">559</a></td>
+    <td><a href="https://wg21.link/cwg559">559</a></td>
     <td>CD1</td>
     <td>Editing error in issue 382 resolution</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="560">
-    <td><a href="http://wg21.link/cwg560">560</a></td>
+    <td><a href="https://wg21.link/cwg560">560</a></td>
     <td>drafting</td>
     <td>Use of the <TT>typename</TT> keyword in return types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="561">
-    <td><a href="http://wg21.link/cwg561">561</a></td>
+    <td><a href="https://wg21.link/cwg561">561</a></td>
     <td>CD2</td>
     <td>Internal linkage functions in dependent name lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="562">
-    <td><a href="http://wg21.link/cwg562">562</a></td>
+    <td><a href="https://wg21.link/cwg562">562</a></td>
     <td>open</td>
     <td><I>qualified-id</I>s in non-expression contexts</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="563">
-    <td><a href="http://wg21.link/cwg563">563</a></td>
+    <td><a href="https://wg21.link/cwg563">563</a></td>
     <td>open</td>
     <td>Linkage specification for objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="564">
-    <td><a href="http://wg21.link/cwg564">564</a></td>
+    <td><a href="https://wg21.link/cwg564">564</a></td>
     <td>CD2</td>
     <td>Agreement of language linkage or <I>linkage-specification</I>s?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="565">
-    <td><a href="http://wg21.link/cwg565">565</a></td>
+    <td><a href="https://wg21.link/cwg565">565</a></td>
     <td>CD3</td>
     <td>Conflict rules for <I>using-declaration</I>s naming function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="566">
-    <td><a href="http://wg21.link/cwg566">566</a></td>
+    <td><a href="https://wg21.link/cwg566">566</a></td>
     <td>NAD</td>
     <td>Conversion of negative floating point values to integer type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="567">
-    <td><a href="http://wg21.link/cwg567">567</a></td>
+    <td><a href="https://wg21.link/cwg567">567</a></td>
     <td>NAD</td>
     <td>Can <TT>size_t</TT> and <TT>ptrdiff_t</TT> be larger than <TT>long</TT>?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="568">
-    <td><a href="http://wg21.link/cwg568">568</a></td>
+    <td><a href="https://wg21.link/cwg568">568</a></td>
     <td>CD1</td>
     <td>Definition of POD is too strict</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="569">
-    <td><a href="http://wg21.link/cwg569">569</a></td>
+    <td><a href="https://wg21.link/cwg569">569</a></td>
     <td>CD2</td>
     <td>Spurious semicolons at namespace scope should be allowed</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="570">
-    <td><a href="http://wg21.link/cwg570">570</a></td>
+    <td><a href="https://wg21.link/cwg570">570</a></td>
     <td>CD2</td>
     <td>Are references subject to the ODR?</td>
     <td class="na" align="center">Duplicate of <a href="#633">633</a></td>
   </tr>
   <tr id="571">
-    <td><a href="http://wg21.link/cwg571">571</a></td>
+    <td><a href="https://wg21.link/cwg571">571</a></td>
     <td>CD2</td>
     <td>References declared <TT>const</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="572">
-    <td><a href="http://wg21.link/cwg572">572</a></td>
+    <td><a href="https://wg21.link/cwg572">572</a></td>
     <td>C++11</td>
     <td>Standard conversions for non-built-in types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="573">
-    <td><a href="http://wg21.link/cwg573">573</a></td>
+    <td><a href="https://wg21.link/cwg573">573</a></td>
     <td>C++11</td>
     <td>Conversions between function pointers and <TT>void*</TT></td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="574">
-    <td><a href="http://wg21.link/cwg574">574</a></td>
+    <td><a href="https://wg21.link/cwg574">574</a></td>
     <td>NAD</td>
     <td>Definition of &#8220;copy assignment operator&#8221;</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="575">
-    <td><a href="http://wg21.link/cwg575">575</a></td>
+    <td><a href="https://wg21.link/cwg575">575</a></td>
     <td>C++11</td>
     <td>Criteria for deduction failure</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="576">
-    <td><a href="http://wg21.link/cwg576">576</a></td>
+    <td><a href="https://wg21.link/cwg576">576</a></td>
     <td>CD2</td>
     <td>Typedefs in function definitions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="577">
-    <td><a href="http://wg21.link/cwg577">577</a></td>
+    <td><a href="https://wg21.link/cwg577">577</a></td>
     <td>CD3</td>
     <td><TT>void</TT> in an empty parameter list</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="578">
-    <td><a href="http://wg21.link/cwg578">578</a></td>
+    <td><a href="https://wg21.link/cwg578">578</a></td>
     <td>open</td>
     <td>Phase 1 replacement of characters with <I>universal-character-name</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="579">
-    <td><a href="http://wg21.link/cwg579">579</a></td>
+    <td><a href="https://wg21.link/cwg579">579</a></td>
     <td>open</td>
     <td>What is a &#8220;nested&#8221; <TT>&gt;</TT> or <TT>&gt;&gt;</TT>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="580">
-    <td><a href="http://wg21.link/cwg580">580</a></td>
+    <td><a href="https://wg21.link/cwg580">580</a></td>
     <td>C++11</td>
     <td>Access in <I>template-parameter</I>s of member and friend definitions</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="581">
-    <td><a href="http://wg21.link/cwg581">581</a></td>
+    <td><a href="https://wg21.link/cwg581">581</a></td>
     <td>DR</td>
     <td>Can a templated constructor be explicitly instantiated or specialized?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="582">
-    <td><a href="http://wg21.link/cwg582">582</a></td>
+    <td><a href="https://wg21.link/cwg582">582</a></td>
     <td>CD1</td>
     <td>Template conversion functions</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="583">
-    <td><a href="http://wg21.link/cwg583">583</a></td>
+    <td><a href="https://wg21.link/cwg583">583</a></td>
     <td>CD3</td>
     <td>Relational pointer comparisons against the null pointer constant</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="584">
-    <td><a href="http://wg21.link/cwg584">584</a></td>
+    <td><a href="https://wg21.link/cwg584">584</a></td>
     <td>NAD</td>
     <td>Unions and aliasing</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="585">
-    <td><a href="http://wg21.link/cwg585">585</a></td>
+    <td><a href="https://wg21.link/cwg585">585</a></td>
     <td>NAD</td>
     <td>Friend template template parameters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="586">
-    <td><a href="http://wg21.link/cwg586">586</a></td>
+    <td><a href="https://wg21.link/cwg586">586</a></td>
     <td>NAD</td>
     <td>Default <I>template-argument</I>s and template argument deduction</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="587">
-    <td><a href="http://wg21.link/cwg587">587</a></td>
+    <td><a href="https://wg21.link/cwg587">587</a></td>
     <td>CD2</td>
     <td>Lvalue operands of a conditional expression differing only in cv-qualification</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="588">
-    <td><a href="http://wg21.link/cwg588">588</a></td>
+    <td><a href="https://wg21.link/cwg588">588</a></td>
     <td>CD2</td>
     <td>Searching dependent bases of classes local to function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="589">
-    <td><a href="http://wg21.link/cwg589">589</a></td>
+    <td><a href="https://wg21.link/cwg589">589</a></td>
     <td>CD2</td>
     <td>Direct binding of class and array rvalues in reference initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="590">
-    <td><a href="http://wg21.link/cwg590">590</a></td>
+    <td><a href="https://wg21.link/cwg590">590</a></td>
     <td>C++11</td>
     <td>Nested classes and the &#8220;current instantiation&#8221;</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="591">
-    <td><a href="http://wg21.link/cwg591">591</a></td>
+    <td><a href="https://wg21.link/cwg591">591</a></td>
     <td>CD4</td>
     <td>When a dependent base class is the current instantiation</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="592">
-    <td><a href="http://wg21.link/cwg592">592</a></td>
+    <td><a href="https://wg21.link/cwg592">592</a></td>
     <td>CD1</td>
     <td>Exceptions during construction of local static objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="593">
-    <td><a href="http://wg21.link/cwg593">593</a></td>
+    <td><a href="https://wg21.link/cwg593">593</a></td>
     <td>NAD</td>
     <td>Falling off the end of a destructor's <I>function-try-block</I> handler</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="594">
-    <td><a href="http://wg21.link/cwg594">594</a></td>
+    <td><a href="https://wg21.link/cwg594">594</a></td>
     <td>CD1</td>
     <td>Coordinating issues 119 and 404 with delegating constructors</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="595">
-    <td><a href="http://wg21.link/cwg595">595</a></td>
+    <td><a href="https://wg21.link/cwg595">595</a></td>
     <td>dup</td>
     <td>Exception specifications in templates instantiated from class bodies</td>
     <td class="full" align="center">Duplicate of <a href="#1330">1330</a></td>
   </tr>
   <tr id="596">
-    <td><a href="http://wg21.link/cwg596">596</a></td>
+    <td><a href="https://wg21.link/cwg596">596</a></td>
     <td>NAD</td>
     <td>Replacing an exception object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="597">
-    <td><a href="http://wg21.link/cwg597">597</a></td>
+    <td><a href="https://wg21.link/cwg597">597</a></td>
     <td>CD3</td>
     <td>Conversions applied to out-of-lifetime non-POD lvalues</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="598">
-    <td><a href="http://wg21.link/cwg598">598</a></td>
+    <td><a href="https://wg21.link/cwg598">598</a></td>
     <td>CD2</td>
     <td>Associated namespaces of overloaded functions and function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="599">
-    <td><a href="http://wg21.link/cwg599">599</a></td>
+    <td><a href="https://wg21.link/cwg599">599</a></td>
     <td>CD2</td>
     <td>Deleting a null function pointer</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr class="open" id="600">
-    <td><a href="http://wg21.link/cwg600">600</a></td>
+    <td><a href="https://wg21.link/cwg600">600</a></td>
     <td>open</td>
     <td>Does access control apply to members or to names?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="601">
-    <td><a href="http://wg21.link/cwg601">601</a></td>
+    <td><a href="https://wg21.link/cwg601">601</a></td>
     <td>CD2</td>
     <td>Type of literals in preprocessing expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="602">
-    <td><a href="http://wg21.link/cwg602">602</a></td>
+    <td><a href="https://wg21.link/cwg602">602</a></td>
     <td>C++11</td>
     <td>When is the injected-class-name of a class template a template?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="603">
-    <td><a href="http://wg21.link/cwg603">603</a></td>
+    <td><a href="https://wg21.link/cwg603">603</a></td>
     <td>CD1</td>
     <td>Type equivalence and unsigned overflow</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="604">
-    <td><a href="http://wg21.link/cwg604">604</a></td>
+    <td><a href="https://wg21.link/cwg604">604</a></td>
     <td>CD2</td>
     <td>Argument list for overload resolution in copy-initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="605">
-    <td><a href="http://wg21.link/cwg605">605</a></td>
+    <td><a href="https://wg21.link/cwg605">605</a></td>
     <td>C++11</td>
     <td>Linkage of explicit specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="606">
-    <td><a href="http://wg21.link/cwg606">606</a></td>
+    <td><a href="https://wg21.link/cwg606">606</a></td>
     <td>CD1</td>
     <td>Template argument deduction for rvalue references</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="607">
-    <td><a href="http://wg21.link/cwg607">607</a></td>
+    <td><a href="https://wg21.link/cwg607">607</a></td>
     <td>open</td>
     <td>Lookup of <I>mem-initializer-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="608">
-    <td><a href="http://wg21.link/cwg608">608</a></td>
+    <td><a href="https://wg21.link/cwg608">608</a></td>
     <td>CD2</td>
     <td>Determining the final overrider of a virtual function</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="609">
-    <td><a href="http://wg21.link/cwg609">609</a></td>
+    <td><a href="https://wg21.link/cwg609">609</a></td>
     <td>CD4</td>
     <td>What is a &#8220;top-level&#8221; cv-qualifier?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="610">
-    <td><a href="http://wg21.link/cwg610">610</a></td>
+    <td><a href="https://wg21.link/cwg610">610</a></td>
     <td>NAD</td>
     <td>Computing the negative of <TT>0U</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="611">
-    <td><a href="http://wg21.link/cwg611">611</a></td>
+    <td><a href="https://wg21.link/cwg611">611</a></td>
     <td>CD2</td>
     <td>Zero-initializing references</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="612">
-    <td><a href="http://wg21.link/cwg612">612</a></td>
+    <td><a href="https://wg21.link/cwg612">612</a></td>
     <td>CD2</td>
     <td>Requirements on a conforming implementation</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="613">
-    <td><a href="http://wg21.link/cwg613">613</a></td>
+    <td><a href="https://wg21.link/cwg613">613</a></td>
     <td>CD1</td>
     <td>Unevaluated uses of non-static class members</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="614">
-    <td><a href="http://wg21.link/cwg614">614</a></td>
+    <td><a href="https://wg21.link/cwg614">614</a></td>
     <td>CD1</td>
     <td>Results of integer <TT>/</TT> and <TT>%</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="615">
-    <td><a href="http://wg21.link/cwg615">615</a></td>
+    <td><a href="https://wg21.link/cwg615">615</a></td>
     <td>C++11</td>
     <td>Incorrect description of variables that can be initialized</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="616">
-    <td><a href="http://wg21.link/cwg616">616</a></td>
+    <td><a href="https://wg21.link/cwg616">616</a></td>
     <td>CD3</td>
     <td>Definition of &#8220;indeterminate value&#8221;</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr class="open" id="617">
-    <td><a href="http://wg21.link/cwg617">617</a></td>
+    <td><a href="https://wg21.link/cwg617">617</a></td>
     <td>drafting</td>
     <td>Lvalue-to-rvalue conversions of uninitialized <TT>char</TT> objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="618">
-    <td><a href="http://wg21.link/cwg618">618</a></td>
+    <td><a href="https://wg21.link/cwg618">618</a></td>
     <td>CD2</td>
     <td>Casts in preprocessor conditional expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="619">
-    <td><a href="http://wg21.link/cwg619">619</a></td>
+    <td><a href="https://wg21.link/cwg619">619</a></td>
     <td>C++11</td>
     <td>Completeness of array types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="620">
-    <td><a href="http://wg21.link/cwg620">620</a></td>
+    <td><a href="https://wg21.link/cwg620">620</a></td>
     <td>CD1</td>
     <td>Declaration order in layout-compatible POD structs</td>
     <td class="full" align="center">Duplicate of <a href="#568">568</a></td>
   </tr>
   <tr id="621">
-    <td><a href="http://wg21.link/cwg621">621</a></td>
+    <td><a href="https://wg21.link/cwg621">621</a></td>
     <td>C++11</td>
     <td>Template argument deduction from function return types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="622">
-    <td><a href="http://wg21.link/cwg622">622</a></td>
+    <td><a href="https://wg21.link/cwg622">622</a></td>
     <td>NAD</td>
     <td>Relational comparisons of arbitrary pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="623">
-    <td><a href="http://wg21.link/cwg623">623</a></td>
+    <td><a href="https://wg21.link/cwg623">623</a></td>
     <td>CD3</td>
     <td>Use of pointers to deallocated storage</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="624">
-    <td><a href="http://wg21.link/cwg624">624</a></td>
+    <td><a href="https://wg21.link/cwg624">624</a></td>
     <td>CD1</td>
     <td>Overflow in calculating size of allocation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="625">
-    <td><a href="http://wg21.link/cwg625">625</a></td>
+    <td><a href="https://wg21.link/cwg625">625</a></td>
     <td>CD2</td>
     <td>Use of <TT>auto</TT> as a <I>template-argument</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="626">
-    <td><a href="http://wg21.link/cwg626">626</a></td>
+    <td><a href="https://wg21.link/cwg626">626</a></td>
     <td>CD2</td>
     <td>Preprocessor string literals</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="627">
-    <td><a href="http://wg21.link/cwg627">627</a></td>
+    <td><a href="https://wg21.link/cwg627">627</a></td>
     <td>NAD</td>
     <td>Values behaving as types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="628">
-    <td><a href="http://wg21.link/cwg628">628</a></td>
+    <td><a href="https://wg21.link/cwg628">628</a></td>
     <td>CD2</td>
     <td>The values of an enumeration with no enumerator</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="629">
-    <td><a href="http://wg21.link/cwg629">629</a></td>
+    <td><a href="https://wg21.link/cwg629">629</a></td>
     <td>CD1</td>
     <td><TT>auto</TT> parsing ambiguity</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="630">
-    <td><a href="http://wg21.link/cwg630">630</a></td>
+    <td><a href="https://wg21.link/cwg630">630</a></td>
     <td>CD2</td>
     <td>Equality of narrow and wide character values in the basic character set</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="631">
-    <td><a href="http://wg21.link/cwg631">631</a></td>
+    <td><a href="https://wg21.link/cwg631">631</a></td>
     <td>CD3</td>
     <td>Jumping into a &#8220;then&#8221; clause</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="632">
-    <td><a href="http://wg21.link/cwg632">632</a></td>
+    <td><a href="https://wg21.link/cwg632">632</a></td>
     <td>CD1</td>
     <td>Brace-enclosed initializer for scalar member of aggregate</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="633">
-    <td><a href="http://wg21.link/cwg633">633</a></td>
+    <td><a href="https://wg21.link/cwg633">633</a></td>
     <td>CD2</td>
     <td>Specifications for variables that should also apply to references</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="634">
-    <td><a href="http://wg21.link/cwg634">634</a></td>
+    <td><a href="https://wg21.link/cwg634">634</a></td>
     <td>CD1</td>
     <td>Conditionally-supported behavior for non-POD objects passed to ellipsis redux</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="635">
-    <td><a href="http://wg21.link/cwg635">635</a></td>
+    <td><a href="https://wg21.link/cwg635">635</a></td>
     <td>NAD</td>
     <td>Names of constructors and destructors of templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="636">
-    <td><a href="http://wg21.link/cwg636">636</a></td>
+    <td><a href="https://wg21.link/cwg636">636</a></td>
     <td>CD4</td>
     <td>Dynamic type of objects and aliasing</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="637">
-    <td><a href="http://wg21.link/cwg637">637</a></td>
+    <td><a href="https://wg21.link/cwg637">637</a></td>
     <td>CD1</td>
     <td>Sequencing rules and example disagree</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="638">
-    <td><a href="http://wg21.link/cwg638">638</a></td>
+    <td><a href="https://wg21.link/cwg638">638</a></td>
     <td>CD2</td>
     <td>Explicit specialization and friendship</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="639">
-    <td><a href="http://wg21.link/cwg639">639</a></td>
+    <td><a href="https://wg21.link/cwg639">639</a></td>
     <td>CD1</td>
     <td>What makes side effects &#8220;different&#8221; from one another?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="640">
-    <td><a href="http://wg21.link/cwg640">640</a></td>
+    <td><a href="https://wg21.link/cwg640">640</a></td>
     <td>open</td>
     <td>Accessing destroyed local objects of static storage duration</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="641">
-    <td><a href="http://wg21.link/cwg641">641</a></td>
+    <td><a href="https://wg21.link/cwg641">641</a></td>
     <td>CD2</td>
     <td>Overload resolution and conversion-to-same-type operators</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="642">
-    <td><a href="http://wg21.link/cwg642">642</a></td>
+    <td><a href="https://wg21.link/cwg642">642</a></td>
     <td>CD2</td>
     <td>Definition and use of &#8220;block scope&#8221; and &#8220;local scope&#8221;</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="643">
-    <td><a href="http://wg21.link/cwg643">643</a></td>
+    <td><a href="https://wg21.link/cwg643">643</a></td>
     <td>NAD</td>
     <td>Use of <TT>decltype</TT> in a class <I>member-specification</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="644">
-    <td><a href="http://wg21.link/cwg644">644</a></td>
+    <td><a href="https://wg21.link/cwg644">644</a></td>
     <td>CD1</td>
     <td>Should a trivial class type be a literal type?</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="645">
-    <td><a href="http://wg21.link/cwg645">645</a></td>
+    <td><a href="https://wg21.link/cwg645">645</a></td>
     <td>CD2</td>
     <td>Are bit-field and non-bit-field members layout compatible?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="646">
-    <td><a href="http://wg21.link/cwg646">646</a></td>
+    <td><a href="https://wg21.link/cwg646">646</a></td>
     <td>NAD</td>
     <td>Can a class with a constexpr copy constructor be a literal type?</td>
     <td class="none" align="center">Superseded by <a href="#981">981</a></td>
   </tr>
   <tr id="647">
-    <td><a href="http://wg21.link/cwg647">647</a></td>
+    <td><a href="https://wg21.link/cwg647">647</a></td>
     <td>CD1</td>
     <td>Non-constexpr instances of constexpr constructor templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="648">
-    <td><a href="http://wg21.link/cwg648">648</a></td>
+    <td><a href="https://wg21.link/cwg648">648</a></td>
     <td>CD1</td>
     <td>Constant expressions in constexpr initializers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="649">
-    <td><a href="http://wg21.link/cwg649">649</a></td>
+    <td><a href="https://wg21.link/cwg649">649</a></td>
     <td>CD1</td>
     <td>Optionally ill-formed extended alignment requests</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="650">
-    <td><a href="http://wg21.link/cwg650">650</a></td>
+    <td><a href="https://wg21.link/cwg650">650</a></td>
     <td>CD2</td>
     <td>Order of destruction for temporaries bound to the returned value of a function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="651">
-    <td><a href="http://wg21.link/cwg651">651</a></td>
+    <td><a href="https://wg21.link/cwg651">651</a></td>
     <td>CD1</td>
     <td>Problems in <TT>decltype</TT> specification and examples</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="652">
-    <td><a href="http://wg21.link/cwg652">652</a></td>
+    <td><a href="https://wg21.link/cwg652">652</a></td>
     <td>CD2</td>
     <td>Compile-time evaluation of floating-point expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="653">
-    <td><a href="http://wg21.link/cwg653">653</a></td>
+    <td><a href="https://wg21.link/cwg653">653</a></td>
     <td>CD2</td>
     <td>Copy assignment of unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="654">
-    <td><a href="http://wg21.link/cwg654">654</a></td>
+    <td><a href="https://wg21.link/cwg654">654</a></td>
     <td>CD1</td>
     <td>Conversions to and from <TT>nullptr_t</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="655">
-    <td><a href="http://wg21.link/cwg655">655</a></td>
+    <td><a href="https://wg21.link/cwg655">655</a></td>
     <td>C++11</td>
     <td>Initialization not specified for forwarding constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="656">
-    <td><a href="http://wg21.link/cwg656">656</a></td>
+    <td><a href="https://wg21.link/cwg656">656</a></td>
     <td>CD2</td>
     <td>Direct binding to the result of a conversion operator</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="657">
-    <td><a href="http://wg21.link/cwg657">657</a></td>
+    <td><a href="https://wg21.link/cwg657">657</a></td>
     <td>CD2</td>
     <td>Abstract class parameter in synthesized declaration</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="658">
-    <td><a href="http://wg21.link/cwg658">658</a></td>
+    <td><a href="https://wg21.link/cwg658">658</a></td>
     <td>CD2</td>
     <td>Defining <TT>reinterpret_cast</TT> for pointer types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="659">
-    <td><a href="http://wg21.link/cwg659">659</a></td>
+    <td><a href="https://wg21.link/cwg659">659</a></td>
     <td>CD1</td>
     <td>Alignment of function types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="660">
-    <td><a href="http://wg21.link/cwg660">660</a></td>
+    <td><a href="https://wg21.link/cwg660">660</a></td>
     <td>CD1</td>
     <td>Unnamed scoped enumerations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="661">
-    <td><a href="http://wg21.link/cwg661">661</a></td>
+    <td><a href="https://wg21.link/cwg661">661</a></td>
     <td>CD1</td>
     <td>Semantics of arithmetic comparisons</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="662">
-    <td><a href="http://wg21.link/cwg662">662</a></td>
+    <td><a href="https://wg21.link/cwg662">662</a></td>
     <td>NAD</td>
     <td>Forming a pointer to a reference type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="663">
-    <td><a href="http://wg21.link/cwg663">663</a></td>
+    <td><a href="https://wg21.link/cwg663">663</a></td>
     <td>CD1</td>
     <td>Valid Cyrillic identifier characters</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="664">
-    <td><a href="http://wg21.link/cwg664">664</a></td>
+    <td><a href="https://wg21.link/cwg664">664</a></td>
     <td>CD2</td>
     <td>Direct binding of references to non-class rvalue references</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="665">
-    <td><a href="http://wg21.link/cwg665">665</a></td>
+    <td><a href="https://wg21.link/cwg665">665</a></td>
     <td>CD2</td>
     <td>Problems in the specification of <TT>dynamic_cast</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="666">
-    <td><a href="http://wg21.link/cwg666">666</a></td>
+    <td><a href="https://wg21.link/cwg666">666</a></td>
     <td>CD1</td>
     <td>Dependent <I>qualified-id</I>s without the <TT>typename</TT> keyword</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="667">
-    <td><a href="http://wg21.link/cwg667">667</a></td>
+    <td><a href="https://wg21.link/cwg667">667</a></td>
     <td>CD2</td>
     <td>Trivial special member functions that cannot be implicitly defined</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="668">
-    <td><a href="http://wg21.link/cwg668">668</a></td>
+    <td><a href="https://wg21.link/cwg668">668</a></td>
     <td>CD2</td>
     <td>Throwing an exception from the destructor of a local static object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="669">
-    <td><a href="http://wg21.link/cwg669">669</a></td>
+    <td><a href="https://wg21.link/cwg669">669</a></td>
     <td>NAD</td>
     <td>Confusing specification of the meaning of <TT>decltype</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="670">
-    <td><a href="http://wg21.link/cwg670">670</a></td>
+    <td><a href="https://wg21.link/cwg670">670</a></td>
     <td>open</td>
     <td>Copy initialization via derived-to-base conversion in the second step</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="671">
-    <td><a href="http://wg21.link/cwg671">671</a></td>
+    <td><a href="https://wg21.link/cwg671">671</a></td>
     <td>CD1</td>
     <td>Explicit conversion from a scoped enumeration type to integral type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="672">
-    <td><a href="http://wg21.link/cwg672">672</a></td>
+    <td><a href="https://wg21.link/cwg672">672</a></td>
     <td>CD2</td>
     <td>Sequencing of initialization in <I>new-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="673">
-    <td><a href="http://wg21.link/cwg673">673</a></td>
+    <td><a href="https://wg21.link/cwg673">673</a></td>
     <td>NAD</td>
     <td>Injection of names from <I>elaborated-type-specifier</I>s in <TT>friend</TT> declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="674">
-    <td><a href="http://wg21.link/cwg674">674</a></td>
+    <td><a href="https://wg21.link/cwg674">674</a></td>
     <td>C++11</td>
     <td>&#8220;matching specialization&#8221; for a friend declaration</td>
     <td class="full" align="center">Clang 8</td>
   </tr>
   <tr id="675">
-    <td><a href="http://wg21.link/cwg675">675</a></td>
+    <td><a href="https://wg21.link/cwg675">675</a></td>
     <td>CD3</td>
     <td>Signedness of bit-field with typedef or template parameter type</td>
     <td class="none" align="center">Duplicate of <a href="#739">739</a></td>
   </tr>
   <tr id="676">
-    <td><a href="http://wg21.link/cwg676">676</a></td>
+    <td><a href="https://wg21.link/cwg676">676</a></td>
     <td>C++11</td>
     <td><I>static_assert-declaration</I>s and general requirements for declarations</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="677">
-    <td><a href="http://wg21.link/cwg677">677</a></td>
+    <td><a href="https://wg21.link/cwg677">677</a></td>
     <td>CD1</td>
     <td>Deleted <TT>operator delete</TT> and virtual destructors</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="678">
-    <td><a href="http://wg21.link/cwg678">678</a></td>
+    <td><a href="https://wg21.link/cwg678">678</a></td>
     <td>C++11</td>
     <td>Language linkage of member function parameter types and the ODR</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="679">
-    <td><a href="http://wg21.link/cwg679">679</a></td>
+    <td><a href="https://wg21.link/cwg679">679</a></td>
     <td>CD1</td>
     <td>Equivalence of <I>template-id</I>s and operator function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="680">
-    <td><a href="http://wg21.link/cwg680">680</a></td>
+    <td><a href="https://wg21.link/cwg680">680</a></td>
     <td>CD2</td>
     <td>What is a move constructor?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="681">
-    <td><a href="http://wg21.link/cwg681">681</a></td>
+    <td><a href="https://wg21.link/cwg681">681</a></td>
     <td>CD1</td>
     <td>Restrictions on declarators with late-specified return types</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="682">
-    <td><a href="http://wg21.link/cwg682">682</a></td>
+    <td><a href="https://wg21.link/cwg682">682</a></td>
     <td>tentatively ready</td>
     <td>Missing description of lookup of template aliases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="683">
-    <td><a href="http://wg21.link/cwg683">683</a></td>
+    <td><a href="https://wg21.link/cwg683">683</a></td>
     <td>CD1</td>
     <td>Requirements for trivial subobject special functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="684">
-    <td><a href="http://wg21.link/cwg684">684</a></td>
+    <td><a href="https://wg21.link/cwg684">684</a></td>
     <td>CD1</td>
     <td>Constant expressions involving the address of an automatic variable</td>
     <td class="none" align="center">Superseded by <a href="#1454">1454</a></td>
   </tr>
   <tr id="685">
-    <td><a href="http://wg21.link/cwg685">685</a></td>
+    <td><a href="https://wg21.link/cwg685">685</a></td>
     <td>CD2</td>
     <td>Integral promotion of enumeration ignores fixed underlying type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="686">
-    <td><a href="http://wg21.link/cwg686">686</a></td>
+    <td><a href="https://wg21.link/cwg686">686</a></td>
     <td>CD1</td>
     <td>Type declarations/definitions in <I>type-specifier-seq</I>s and <I>type-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="687">
-    <td><a href="http://wg21.link/cwg687">687</a></td>
+    <td><a href="https://wg21.link/cwg687">687</a></td>
     <td>extension</td>
     <td><TT>template</TT> keyword with <I>unqualified-id</I>s</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="688">
-    <td><a href="http://wg21.link/cwg688">688</a></td>
+    <td><a href="https://wg21.link/cwg688">688</a></td>
     <td>CD1</td>
     <td>Constexpr constructors and static initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="689">
-    <td><a href="http://wg21.link/cwg689">689</a></td>
+    <td><a href="https://wg21.link/cwg689">689</a></td>
     <td>open</td>
     <td>Maximum values of signed and unsigned integers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="690">
-    <td><a href="http://wg21.link/cwg690">690</a></td>
+    <td><a href="https://wg21.link/cwg690">690</a></td>
     <td>CD2</td>
     <td>The dynamic type of an rvalue reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="691">
-    <td><a href="http://wg21.link/cwg691">691</a></td>
+    <td><a href="https://wg21.link/cwg691">691</a></td>
     <td>C++11</td>
     <td>Template parameter packs in class template partial specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="692">
-    <td><a href="http://wg21.link/cwg692">692</a></td>
+    <td><a href="https://wg21.link/cwg692">692</a></td>
     <td>C++11</td>
     <td>Partial ordering of variadic class template partial specializations</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="693">
-    <td><a href="http://wg21.link/cwg693">693</a></td>
+    <td><a href="https://wg21.link/cwg693">693</a></td>
     <td>CD2</td>
     <td>New string types and deprecated conversion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="694">
-    <td><a href="http://wg21.link/cwg694">694</a></td>
+    <td><a href="https://wg21.link/cwg694">694</a></td>
     <td>C++11</td>
     <td>Zero- and value-initialization of union objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="695">
-    <td><a href="http://wg21.link/cwg695">695</a></td>
+    <td><a href="https://wg21.link/cwg695">695</a></td>
     <td>CD2</td>
     <td>Compile-time calculation errors in constexpr functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="696">
-    <td><a href="http://wg21.link/cwg696">696</a></td>
+    <td><a href="https://wg21.link/cwg696">696</a></td>
     <td>C++11</td>
     <td>Use of block-scope constants in local classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="697">
-    <td><a href="http://wg21.link/cwg697">697</a></td>
+    <td><a href="https://wg21.link/cwg697">697</a></td>
     <td>open</td>
     <td>Deduction rules apply to more than functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="698">
-    <td><a href="http://wg21.link/cwg698">698</a></td>
+    <td><a href="https://wg21.link/cwg698">698</a></td>
     <td>open</td>
     <td>The definition of &#8220;sequenced before&#8221; is too narrow</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="699">
-    <td><a href="http://wg21.link/cwg699">699</a></td>
+    <td><a href="https://wg21.link/cwg699">699</a></td>
     <td>CD2</td>
     <td>Must constexpr member functions be defined in the class <I>member-specification</I>?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="700">
-    <td><a href="http://wg21.link/cwg700">700</a></td>
+    <td><a href="https://wg21.link/cwg700">700</a></td>
     <td>C++11</td>
     <td>Constexpr member functions of class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="701">
-    <td><a href="http://wg21.link/cwg701">701</a></td>
+    <td><a href="https://wg21.link/cwg701">701</a></td>
     <td>CD2</td>
     <td>When is the array-to-pointer conversion applied?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="702">
-    <td><a href="http://wg21.link/cwg702">702</a></td>
+    <td><a href="https://wg21.link/cwg702">702</a></td>
     <td>CD2</td>
     <td>Preferring conversion to <TT>std::initializer_list</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="703">
-    <td><a href="http://wg21.link/cwg703">703</a></td>
+    <td><a href="https://wg21.link/cwg703">703</a></td>
     <td>CD2</td>
     <td>Narrowing for literals that cannot be exactly represented</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="704">
-    <td><a href="http://wg21.link/cwg704">704</a></td>
+    <td><a href="https://wg21.link/cwg704">704</a></td>
     <td>CD2</td>
     <td>To which <I>postfix-expression</I>s does overload resolution apply?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="705">
-    <td><a href="http://wg21.link/cwg705">705</a></td>
+    <td><a href="https://wg21.link/cwg705">705</a></td>
     <td>CD2</td>
     <td>Suppressing argument-dependent lookup via parentheses</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="706">
-    <td><a href="http://wg21.link/cwg706">706</a></td>
+    <td><a href="https://wg21.link/cwg706">706</a></td>
     <td>NAD</td>
     <td>Use of <TT>auto</TT> with rvalue references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="707">
-    <td><a href="http://wg21.link/cwg707">707</a></td>
+    <td><a href="https://wg21.link/cwg707">707</a></td>
     <td>CD2</td>
     <td>Undefined behavior in integral-to-floating conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="708">
-    <td><a href="http://wg21.link/cwg708">708</a></td>
+    <td><a href="https://wg21.link/cwg708">708</a></td>
     <td>open</td>
     <td>Partial specialization of member templates of class templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="709">
-    <td><a href="http://wg21.link/cwg709">709</a></td>
+    <td><a href="https://wg21.link/cwg709">709</a></td>
     <td>C++11</td>
     <td>Enumeration names as <I>nested-name-specifier</I>s in deduction failure</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="710">
-    <td><a href="http://wg21.link/cwg710">710</a></td>
+    <td><a href="https://wg21.link/cwg710">710</a></td>
     <td>CD2</td>
     <td>Data races during construction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="711">
-    <td><a href="http://wg21.link/cwg711">711</a></td>
+    <td><a href="https://wg21.link/cwg711">711</a></td>
     <td>CD2</td>
     <td><TT>auto</TT> with <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="712">
-    <td><a href="http://wg21.link/cwg712">712</a></td>
+    <td><a href="https://wg21.link/cwg712">712</a></td>
     <td>CD3</td>
     <td>Are integer constant operands of a <I>conditional-expression</I> &#8220;used?&#8221;</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="713">
-    <td><a href="http://wg21.link/cwg713">713</a></td>
+    <td><a href="https://wg21.link/cwg713">713</a></td>
     <td>CD2</td>
     <td>Unclear note about cv-qualified function types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="714">
-    <td><a href="http://wg21.link/cwg714">714</a></td>
+    <td><a href="https://wg21.link/cwg714">714</a></td>
     <td>CD2</td>
     <td>Static const data members and <I>braced-init-list</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="715">
-    <td><a href="http://wg21.link/cwg715">715</a></td>
+    <td><a href="https://wg21.link/cwg715">715</a></td>
     <td>CD2</td>
     <td>Class member access constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="716">
-    <td><a href="http://wg21.link/cwg716">716</a></td>
+    <td><a href="https://wg21.link/cwg716">716</a></td>
     <td>CD2</td>
     <td>Specifications that should apply only to non-static union data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="717">
-    <td><a href="http://wg21.link/cwg717">717</a></td>
+    <td><a href="https://wg21.link/cwg717">717</a></td>
     <td>CD2</td>
     <td>Unintentional restrictions on the use of <TT>thread_local</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="718">
-    <td><a href="http://wg21.link/cwg718">718</a></td>
+    <td><a href="https://wg21.link/cwg718">718</a></td>
     <td>open</td>
     <td>Non-class, non-function friend declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="719">
-    <td><a href="http://wg21.link/cwg719">719</a></td>
+    <td><a href="https://wg21.link/cwg719">719</a></td>
     <td>CD2</td>
     <td>Specifications for <I>operator-function-id</I> that should also apply to <I>literal-operator-id</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="720">
-    <td><a href="http://wg21.link/cwg720">720</a></td>
+    <td><a href="https://wg21.link/cwg720">720</a></td>
     <td>CD2</td>
     <td>Need examples of <I>lambda-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="721">
-    <td><a href="http://wg21.link/cwg721">721</a></td>
+    <td><a href="https://wg21.link/cwg721">721</a></td>
     <td>CD2</td>
     <td>Where must a variable be initialized to be used in a constant expression?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="722">
-    <td><a href="http://wg21.link/cwg722">722</a></td>
+    <td><a href="https://wg21.link/cwg722">722</a></td>
     <td>CD2</td>
     <td>Can <TT>nullptr</TT> be passed to an ellipsis?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="726">
-    <td><a href="http://wg21.link/cwg726">726</a></td>
+    <td><a href="https://wg21.link/cwg726">726</a></td>
     <td>CD2</td>
     <td>Atomic and non-atomic objects in the memory model</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="727">
-    <td><a href="http://wg21.link/cwg727">727</a></td>
+    <td><a href="https://wg21.link/cwg727">727</a></td>
     <td>C++17</td>
     <td>In-class explicit specializations</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr class="open" id="728">
-    <td><a href="http://wg21.link/cwg728">728</a></td>
+    <td><a href="https://wg21.link/cwg728">728</a></td>
     <td>extension</td>
     <td>Restrictions on local classes</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="729">
-    <td><a href="http://wg21.link/cwg729">729</a></td>
+    <td><a href="https://wg21.link/cwg729">729</a></td>
     <td>CD3</td>
     <td>Qualification conversions and handlers of reference-to-pointer type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="730">
-    <td><a href="http://wg21.link/cwg730">730</a></td>
+    <td><a href="https://wg21.link/cwg730">730</a></td>
     <td>CD2</td>
     <td>Explicit specializations of members of non-template classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="731">
-    <td><a href="http://wg21.link/cwg731">731</a></td>
+    <td><a href="https://wg21.link/cwg731">731</a></td>
     <td>CD2</td>
     <td>Omitted reference qualification of member function type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="732">
-    <td><a href="http://wg21.link/cwg732">732</a></td>
+    <td><a href="https://wg21.link/cwg732">732</a></td>
     <td>CD2</td>
     <td>Late-specified return types in function definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="733">
-    <td><a href="http://wg21.link/cwg733">733</a></td>
+    <td><a href="https://wg21.link/cwg733">733</a></td>
     <td>NAD</td>
     <td>Reference qualification of copy assignment operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="734">
-    <td><a href="http://wg21.link/cwg734">734</a></td>
+    <td><a href="https://wg21.link/cwg734">734</a></td>
     <td>CD2</td>
     <td>Are unique addresses required for namespace-scope variables?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="735">
-    <td><a href="http://wg21.link/cwg735">735</a></td>
+    <td><a href="https://wg21.link/cwg735">735</a></td>
     <td>CD2</td>
     <td>Missing case in specification of safely-derived pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="736">
-    <td><a href="http://wg21.link/cwg736">736</a></td>
+    <td><a href="https://wg21.link/cwg736">736</a></td>
     <td>NAD</td>
     <td>Is the <TT>&amp;</TT> <I>ref-qualifier</I> needed?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="737">
-    <td><a href="http://wg21.link/cwg737">737</a></td>
+    <td><a href="https://wg21.link/cwg737">737</a></td>
     <td>CD2</td>
     <td>Uninitialized trailing characters in string initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="738">
-    <td><a href="http://wg21.link/cwg738">738</a></td>
+    <td><a href="https://wg21.link/cwg738">738</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> not permitted by the syntax of constructor declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="739">
-    <td><a href="http://wg21.link/cwg739">739</a></td>
+    <td><a href="https://wg21.link/cwg739">739</a></td>
     <td>CD3</td>
     <td>Signedness of plain bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="740">
-    <td><a href="http://wg21.link/cwg740">740</a></td>
+    <td><a href="https://wg21.link/cwg740">740</a></td>
     <td>CD2</td>
     <td>Incorrect note on data races</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="741">
-    <td><a href="http://wg21.link/cwg741">741</a></td>
+    <td><a href="https://wg21.link/cwg741">741</a></td>
     <td>C++11</td>
     <td>&#8220;plain&#8221; <TT>long long</TT> bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="742">
-    <td><a href="http://wg21.link/cwg742">742</a></td>
+    <td><a href="https://wg21.link/cwg742">742</a></td>
     <td>open</td>
     <td>Postfix increment/decrement with long bit-field operands</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="743">
-    <td><a href="http://wg21.link/cwg743">743</a></td>
+    <td><a href="https://wg21.link/cwg743">743</a></td>
     <td>CD2</td>
     <td>Use of <TT>decltype</TT> in a <I>nested-name-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="744">
-    <td><a href="http://wg21.link/cwg744">744</a></td>
+    <td><a href="https://wg21.link/cwg744">744</a></td>
     <td>CD2</td>
     <td>Matching template arguments with template template parameters with parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="745">
-    <td><a href="http://wg21.link/cwg745">745</a></td>
+    <td><a href="https://wg21.link/cwg745">745</a></td>
     <td>open</td>
     <td>Effect of ill-formedness resulting from <TT>#error</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="746">
-    <td><a href="http://wg21.link/cwg746">746</a></td>
+    <td><a href="https://wg21.link/cwg746">746</a></td>
     <td>CD2</td>
     <td>Use of <TT>auto</TT> in <I>new-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="747">
-    <td><a href="http://wg21.link/cwg747">747</a></td>
+    <td><a href="https://wg21.link/cwg747">747</a></td>
     <td>dup</td>
     <td>Access of protected base classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="749">
-    <td><a href="http://wg21.link/cwg749">749</a></td>
+    <td><a href="https://wg21.link/cwg749">749</a></td>
     <td>CD2</td>
     <td>References to function types with a <I>cv-qualifier</I> or <I>ref-qualifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="750">
-    <td><a href="http://wg21.link/cwg750">750</a></td>
+    <td><a href="https://wg21.link/cwg750">750</a></td>
     <td>CD2</td>
     <td>Implementation constraints on reference-only closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="751">
-    <td><a href="http://wg21.link/cwg751">751</a></td>
+    <td><a href="https://wg21.link/cwg751">751</a></td>
     <td>CD2</td>
     <td>Deriving from closure classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="752">
-    <td><a href="http://wg21.link/cwg752">752</a></td>
+    <td><a href="https://wg21.link/cwg752">752</a></td>
     <td>CD2</td>
     <td>Name lookup in nested <I>lambda-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="753">
-    <td><a href="http://wg21.link/cwg753">753</a></td>
+    <td><a href="https://wg21.link/cwg753">753</a></td>
     <td>CD2</td>
     <td>Array names in lambda capture sets</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="754">
-    <td><a href="http://wg21.link/cwg754">754</a></td>
+    <td><a href="https://wg21.link/cwg754">754</a></td>
     <td>CD2</td>
     <td>Lambda expressions in default arguments of block-scope function declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="755">
-    <td><a href="http://wg21.link/cwg755">755</a></td>
+    <td><a href="https://wg21.link/cwg755">755</a></td>
     <td>CD3</td>
     <td>Generalized <I>lambda-capture</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="756">
-    <td><a href="http://wg21.link/cwg756">756</a></td>
+    <td><a href="https://wg21.link/cwg756">756</a></td>
     <td>CD2</td>
     <td>Dropping cv-qualification on members of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="757">
-    <td><a href="http://wg21.link/cwg757">757</a></td>
+    <td><a href="https://wg21.link/cwg757">757</a></td>
     <td>CD2</td>
     <td>Types without linkage in declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="758">
-    <td><a href="http://wg21.link/cwg758">758</a></td>
+    <td><a href="https://wg21.link/cwg758">758</a></td>
     <td>C++11</td>
     <td>Missing cases of declarations that are not definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="759">
-    <td><a href="http://wg21.link/cwg759">759</a></td>
+    <td><a href="https://wg21.link/cwg759">759</a></td>
     <td>CD2</td>
     <td>Destruction of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="760">
-    <td><a href="http://wg21.link/cwg760">760</a></td>
+    <td><a href="https://wg21.link/cwg760">760</a></td>
     <td>CD2</td>
     <td><TT>this</TT> inside a nested class of a non-static member function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="761">
-    <td><a href="http://wg21.link/cwg761">761</a></td>
+    <td><a href="https://wg21.link/cwg761">761</a></td>
     <td>CD2</td>
     <td>Inferred return type of closure object call operator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="762">
-    <td><a href="http://wg21.link/cwg762">762</a></td>
+    <td><a href="https://wg21.link/cwg762">762</a></td>
     <td>CD2</td>
     <td>Name lookup in the <I>compound-statement</I> of a lambda expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="763">
-    <td><a href="http://wg21.link/cwg763">763</a></td>
+    <td><a href="https://wg21.link/cwg763">763</a></td>
     <td>CD2</td>
     <td>Is a closure object's <TT>operator()</TT> inline?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="764">
-    <td><a href="http://wg21.link/cwg764">764</a></td>
+    <td><a href="https://wg21.link/cwg764">764</a></td>
     <td>CD2</td>
     <td>Capturing unused variables in a lambda expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="765">
-    <td><a href="http://wg21.link/cwg765">765</a></td>
+    <td><a href="https://wg21.link/cwg765">765</a></td>
     <td>CD2</td>
     <td>Local types in inline functions with external linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="766">
-    <td><a href="http://wg21.link/cwg766">766</a></td>
+    <td><a href="https://wg21.link/cwg766">766</a></td>
     <td>CD2</td>
     <td>Where may lambda expressions appear?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="767">
-    <td><a href="http://wg21.link/cwg767">767</a></td>
+    <td><a href="https://wg21.link/cwg767">767</a></td>
     <td>CD2</td>
     <td><TT>void</TT> and other unnamed <I>lambda-parameter</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="768">
-    <td><a href="http://wg21.link/cwg768">768</a></td>
+    <td><a href="https://wg21.link/cwg768">768</a></td>
     <td>CD2</td>
     <td>Ellipsis in a lambda parameter list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="769">
-    <td><a href="http://wg21.link/cwg769">769</a></td>
+    <td><a href="https://wg21.link/cwg769">769</a></td>
     <td>CD2</td>
     <td>Initialization of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="770">
-    <td><a href="http://wg21.link/cwg770">770</a></td>
+    <td><a href="https://wg21.link/cwg770">770</a></td>
     <td>CD2</td>
     <td>Ambiguity in late-specified return type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="771">
-    <td><a href="http://wg21.link/cwg771">771</a></td>
+    <td><a href="https://wg21.link/cwg771">771</a></td>
     <td>CD2</td>
     <td>Move-construction of reference members of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="772">
-    <td><a href="http://wg21.link/cwg772">772</a></td>
+    <td><a href="https://wg21.link/cwg772">772</a></td>
     <td>CD2</td>
     <td><I>capture-default</I> in lambdas in local default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="773">
-    <td><a href="http://wg21.link/cwg773">773</a></td>
+    <td><a href="https://wg21.link/cwg773">773</a></td>
     <td>C++11</td>
     <td>Parentheses in address non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="774">
-    <td><a href="http://wg21.link/cwg774">774</a></td>
+    <td><a href="https://wg21.link/cwg774">774</a></td>
     <td>CD2</td>
     <td>Can a closure class be a POD?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="775">
-    <td><a href="http://wg21.link/cwg775">775</a></td>
+    <td><a href="https://wg21.link/cwg775">775</a></td>
     <td>CD2</td>
     <td>Capturing references to functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="776">
-    <td><a href="http://wg21.link/cwg776">776</a></td>
+    <td><a href="https://wg21.link/cwg776">776</a></td>
     <td>CD2</td>
     <td>Delegating constructors, destructors, and <TT>std::exit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="777">
-    <td><a href="http://wg21.link/cwg777">777</a></td>
+    <td><a href="https://wg21.link/cwg777">777</a></td>
     <td>CD2</td>
     <td>Default arguments and parameter packs</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="778">
-    <td><a href="http://wg21.link/cwg778">778</a></td>
+    <td><a href="https://wg21.link/cwg778">778</a></td>
     <td>C++11</td>
     <td>Template parameter packs in non-type template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="779">
-    <td><a href="http://wg21.link/cwg779">779</a></td>
+    <td><a href="https://wg21.link/cwg779">779</a></td>
     <td>CD2</td>
     <td>Rvalue reference members of closure objects?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="782">
-    <td><a href="http://wg21.link/cwg782">782</a></td>
+    <td><a href="https://wg21.link/cwg782">782</a></td>
     <td>CD2</td>
     <td>Lambda expressions and argument-dependent lookup</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="783">
-    <td><a href="http://wg21.link/cwg783">783</a></td>
+    <td><a href="https://wg21.link/cwg783">783</a></td>
     <td>open</td>
     <td>Definition of &#8220;argument&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="784">
-    <td><a href="http://wg21.link/cwg784">784</a></td>
+    <td><a href="https://wg21.link/cwg784">784</a></td>
     <td>C++11</td>
     <td>List of incompatibilities with the previous Standard</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="785">
-    <td><a href="http://wg21.link/cwg785">785</a></td>
+    <td><a href="https://wg21.link/cwg785">785</a></td>
     <td>CD2</td>
     <td>&#8220;Execution sequence&#8221; is inappropriate phraseology</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="786">
-    <td><a href="http://wg21.link/cwg786">786</a></td>
+    <td><a href="https://wg21.link/cwg786">786</a></td>
     <td>CD2</td>
     <td>Definition of &#8220;thread&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="787">
-    <td><a href="http://wg21.link/cwg787">787</a></td>
+    <td><a href="https://wg21.link/cwg787">787</a></td>
     <td>CD2</td>
     <td>Unnecessary lexical undefined behavior</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="788">
-    <td><a href="http://wg21.link/cwg788">788</a></td>
+    <td><a href="https://wg21.link/cwg788">788</a></td>
     <td>CD2</td>
     <td>Relationship between locale and values of the execution character set</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="789">
-    <td><a href="http://wg21.link/cwg789">789</a></td>
+    <td><a href="https://wg21.link/cwg789">789</a></td>
     <td>CD2</td>
     <td>Deprecating trigraphs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="790">
-    <td><a href="http://wg21.link/cwg790">790</a></td>
+    <td><a href="https://wg21.link/cwg790">790</a></td>
     <td>CD2</td>
     <td>Concatenation of raw and non-raw string literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="792">
-    <td><a href="http://wg21.link/cwg792">792</a></td>
+    <td><a href="https://wg21.link/cwg792">792</a></td>
     <td>CD2</td>
     <td>Effects of <TT>std::quick_exit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="793">
-    <td><a href="http://wg21.link/cwg793">793</a></td>
+    <td><a href="https://wg21.link/cwg793">793</a></td>
     <td>CD2</td>
     <td>Use of class members during destruction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="794">
-    <td><a href="http://wg21.link/cwg794">794</a></td>
+    <td><a href="https://wg21.link/cwg794">794</a></td>
     <td>extension</td>
     <td>Base-derived conversion in member type of pointer-to-member conversion</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="795">
-    <td><a href="http://wg21.link/cwg795">795</a></td>
+    <td><a href="https://wg21.link/cwg795">795</a></td>
     <td>NAD</td>
     <td>Dependency of lambdas on <TT>&lt;functional&gt;</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="796">
-    <td><a href="http://wg21.link/cwg796">796</a></td>
+    <td><a href="https://wg21.link/cwg796">796</a></td>
     <td>CD2</td>
     <td>Lifetime of a closure object with members captured by reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="797">
-    <td><a href="http://wg21.link/cwg797">797</a></td>
+    <td><a href="https://wg21.link/cwg797">797</a></td>
     <td>CD2</td>
     <td>Converting a no-capture lambda to a function type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="798">
-    <td><a href="http://wg21.link/cwg798">798</a></td>
+    <td><a href="https://wg21.link/cwg798">798</a></td>
     <td>C++11</td>
     <td>Overloaded subscript operator described in clause 5</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="799">
-    <td><a href="http://wg21.link/cwg799">799</a></td>
+    <td><a href="https://wg21.link/cwg799">799</a></td>
     <td>CD2</td>
     <td>Can <TT>reinterpret_cast</TT> be used to cast an operand to its own type?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="800">
-    <td><a href="http://wg21.link/cwg800">800</a></td>
+    <td><a href="https://wg21.link/cwg800">800</a></td>
     <td>NAD</td>
     <td>Safely-derived pointers and object pointers converted from function pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="801">
-    <td><a href="http://wg21.link/cwg801">801</a></td>
+    <td><a href="https://wg21.link/cwg801">801</a></td>
     <td>CD2</td>
     <td>Casting away constness in a cast to rvalue reference type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="803">
-    <td><a href="http://wg21.link/cwg803">803</a></td>
+    <td><a href="https://wg21.link/cwg803">803</a></td>
     <td>CD2</td>
     <td><TT>sizeof</TT> an enumeration type with a fixed underlying type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="804">
-    <td><a href="http://wg21.link/cwg804">804</a></td>
+    <td><a href="https://wg21.link/cwg804">804</a></td>
     <td>CD2</td>
     <td>Deducing the type in <TT>new auto(x)</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="805">
-    <td><a href="http://wg21.link/cwg805">805</a></td>
+    <td><a href="https://wg21.link/cwg805">805</a></td>
     <td>CD2</td>
     <td>Which exception to throw for overflow in array size calculation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="806">
-    <td><a href="http://wg21.link/cwg806">806</a></td>
+    <td><a href="https://wg21.link/cwg806">806</a></td>
     <td>CD2</td>
     <td>Enumeration types in integral constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="807">
-    <td><a href="http://wg21.link/cwg807">807</a></td>
+    <td><a href="https://wg21.link/cwg807">807</a></td>
     <td>NAD</td>
     <td><TT>typeid</TT> expressions in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="808">
-    <td><a href="http://wg21.link/cwg808">808</a></td>
+    <td><a href="https://wg21.link/cwg808">808</a></td>
     <td>CD2</td>
     <td>Non-type <I>decl-specifier</I>s versus max-munch</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="809">
-    <td><a href="http://wg21.link/cwg809">809</a></td>
+    <td><a href="https://wg21.link/cwg809">809</a></td>
     <td>CD2</td>
     <td>Deprecation of the <TT>register</TT> keyword</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="810">
-    <td><a href="http://wg21.link/cwg810">810</a></td>
+    <td><a href="https://wg21.link/cwg810">810</a></td>
     <td>CD2</td>
     <td>Block-scope <TT>thread_local</TT> variables should be implicitly <TT>static</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="811">
-    <td><a href="http://wg21.link/cwg811">811</a></td>
+    <td><a href="https://wg21.link/cwg811">811</a></td>
     <td>CD2</td>
     <td>Unclear implications of const-qualification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="812">
-    <td><a href="http://wg21.link/cwg812">812</a></td>
+    <td><a href="https://wg21.link/cwg812">812</a></td>
     <td>CD2</td>
     <td>Duplicate names in inline namespaces</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="813">
-    <td><a href="http://wg21.link/cwg813">813</a></td>
+    <td><a href="https://wg21.link/cwg813">813</a></td>
     <td>open</td>
     <td><TT>typename</TT> in a <I>using-declaration</I> with a non-dependent name</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="814">
-    <td><a href="http://wg21.link/cwg814">814</a></td>
+    <td><a href="https://wg21.link/cwg814">814</a></td>
     <td>CD2</td>
     <td>Attribute to indicate that a function throws nothing</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="815">
-    <td><a href="http://wg21.link/cwg815">815</a></td>
+    <td><a href="https://wg21.link/cwg815">815</a></td>
     <td>CD2</td>
     <td>Parameter pack expansion inside attributes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="816">
-    <td><a href="http://wg21.link/cwg816">816</a></td>
+    <td><a href="https://wg21.link/cwg816">816</a></td>
     <td>CD2</td>
     <td>Diagnosing violations of <TT>[[final]]</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="817">
-    <td><a href="http://wg21.link/cwg817">817</a></td>
+    <td><a href="https://wg21.link/cwg817">817</a></td>
     <td>CD2</td>
     <td>Meaning of <TT>[[final]]</TT> applied to a class definition</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="818">
-    <td><a href="http://wg21.link/cwg818">818</a></td>
+    <td><a href="https://wg21.link/cwg818">818</a></td>
     <td>CD2</td>
     <td>Function parameter packs in non-final positions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="819">
-    <td><a href="http://wg21.link/cwg819">819</a></td>
+    <td><a href="https://wg21.link/cwg819">819</a></td>
     <td>NAD</td>
     <td>Access control and deleted implicitly-declared special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="820">
-    <td><a href="http://wg21.link/cwg820">820</a></td>
+    <td><a href="https://wg21.link/cwg820">820</a></td>
     <td>CD2</td>
     <td>Deprecation of <TT>export</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="822">
-    <td><a href="http://wg21.link/cwg822">822</a></td>
+    <td><a href="https://wg21.link/cwg822">822</a></td>
     <td>NAD</td>
     <td>Additional contexts for template aliases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="823">
-    <td><a href="http://wg21.link/cwg823">823</a></td>
+    <td><a href="https://wg21.link/cwg823">823</a></td>
     <td>CD2</td>
     <td>Literal types with constexpr conversions as non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="828">
-    <td><a href="http://wg21.link/cwg828">828</a></td>
+    <td><a href="https://wg21.link/cwg828">828</a></td>
     <td>CD2</td>
     <td>Destruction of exception objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="829">
-    <td><a href="http://wg21.link/cwg829">829</a></td>
+    <td><a href="https://wg21.link/cwg829">829</a></td>
     <td>NAD</td>
     <td>At what point is <TT>std::unexpected</TT> called?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="830">
-    <td><a href="http://wg21.link/cwg830">830</a></td>
+    <td><a href="https://wg21.link/cwg830">830</a></td>
     <td>CD2</td>
     <td>Deprecating exception specifications</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="831">
-    <td><a href="http://wg21.link/cwg831">831</a></td>
+    <td><a href="https://wg21.link/cwg831">831</a></td>
     <td>CD2</td>
     <td>Limit on recursively nested template instantiations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="832">
-    <td><a href="http://wg21.link/cwg832">832</a></td>
+    <td><a href="https://wg21.link/cwg832">832</a></td>
     <td>CD2</td>
     <td>Value of preprocessing numbers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="833">
-    <td><a href="http://wg21.link/cwg833">833</a></td>
+    <td><a href="https://wg21.link/cwg833">833</a></td>
     <td>CD2</td>
     <td>Explicit conversion of a scoped enumeration value to a floating type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="834">
-    <td><a href="http://wg21.link/cwg834">834</a></td>
+    <td><a href="https://wg21.link/cwg834">834</a></td>
     <td>CD2</td>
     <td>What is an &#8220;ordinary string literal&#8221;?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="835">
-    <td><a href="http://wg21.link/cwg835">835</a></td>
+    <td><a href="https://wg21.link/cwg835">835</a></td>
     <td>CD2</td>
     <td>Scoped enumerations and the &#8220;usual arithmetic conversions&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="836">
-    <td><a href="http://wg21.link/cwg836">836</a></td>
+    <td><a href="https://wg21.link/cwg836">836</a></td>
     <td>NAD</td>
     <td><TT>[[noreturn]]</TT> applied to function types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="837">
-    <td><a href="http://wg21.link/cwg837">837</a></td>
+    <td><a href="https://wg21.link/cwg837">837</a></td>
     <td>C++11</td>
     <td>Constexpr functions and <TT>return</TT> <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="838">
-    <td><a href="http://wg21.link/cwg838">838</a></td>
+    <td><a href="https://wg21.link/cwg838">838</a></td>
     <td>C++11</td>
     <td>Use of <TT>this</TT> in a <I>brace-or-equal-initializer</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="839">
-    <td><a href="http://wg21.link/cwg839">839</a></td>
+    <td><a href="https://wg21.link/cwg839">839</a></td>
     <td>dup</td>
     <td><TT>sizeof</TT> with opaque enumerations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="840">
-    <td><a href="http://wg21.link/cwg840">840</a></td>
+    <td><a href="https://wg21.link/cwg840">840</a></td>
     <td>CD2</td>
     <td>Rvalue references as nontype template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="842">
-    <td><a href="http://wg21.link/cwg842">842</a></td>
+    <td><a href="https://wg21.link/cwg842">842</a></td>
     <td>CD2</td>
     <td>Casting to rvalue reference type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="845">
-    <td><a href="http://wg21.link/cwg845">845</a></td>
+    <td><a href="https://wg21.link/cwg845">845</a></td>
     <td>CD2</td>
     <td>What is the &#8220;first declaration&#8221; of an explicit specialization?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="846">
-    <td><a href="http://wg21.link/cwg846">846</a></td>
+    <td><a href="https://wg21.link/cwg846">846</a></td>
     <td>CD2</td>
     <td>Rvalue references to functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="847">
-    <td><a href="http://wg21.link/cwg847">847</a></td>
+    <td><a href="https://wg21.link/cwg847">847</a></td>
     <td>CD2</td>
     <td>Error in rvalue reference deduction example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="850">
-    <td><a href="http://wg21.link/cwg850">850</a></td>
+    <td><a href="https://wg21.link/cwg850">850</a></td>
     <td>CD2</td>
     <td>Restrictions on use of non-static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="852">
-    <td><a href="http://wg21.link/cwg852">852</a></td>
+    <td><a href="https://wg21.link/cwg852">852</a></td>
     <td>open</td>
     <td><I>using-declaration</I>s and dependent base classes</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="853">
-    <td><a href="http://wg21.link/cwg853">853</a></td>
+    <td><a href="https://wg21.link/cwg853">853</a></td>
     <td>CD2</td>
     <td>Support for relaxed pointer safety</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="854">
-    <td><a href="http://wg21.link/cwg854">854</a></td>
+    <td><a href="https://wg21.link/cwg854">854</a></td>
     <td>CD2</td>
     <td>Left shift and unsigned extended types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="855">
-    <td><a href="http://wg21.link/cwg855">855</a></td>
+    <td><a href="https://wg21.link/cwg855">855</a></td>
     <td>CD2</td>
     <td>Incorrect comments in <I>braced-init-list</I> assignment example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="858">
-    <td><a href="http://wg21.link/cwg858">858</a></td>
+    <td><a href="https://wg21.link/cwg858">858</a></td>
     <td>CD2</td>
     <td>Example binding an rvalue reference to an lvalue</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="860">
-    <td><a href="http://wg21.link/cwg860">860</a></td>
+    <td><a href="https://wg21.link/cwg860">860</a></td>
     <td>C++11</td>
     <td>Explicit qualification of constexpr member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="861">
-    <td><a href="http://wg21.link/cwg861">861</a></td>
+    <td><a href="https://wg21.link/cwg861">861</a></td>
     <td>CD2</td>
     <td>Unintended ambiguity in inline namespace lookup</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="862">
-    <td><a href="http://wg21.link/cwg862">862</a></td>
+    <td><a href="https://wg21.link/cwg862">862</a></td>
     <td>CD2</td>
     <td>Undefined behavior with enumerator value overflow</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="863">
-    <td><a href="http://wg21.link/cwg863">863</a></td>
+    <td><a href="https://wg21.link/cwg863">863</a></td>
     <td>CD2</td>
     <td>Rvalue reference cast to incomplete type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="864">
-    <td><a href="http://wg21.link/cwg864">864</a></td>
+    <td><a href="https://wg21.link/cwg864">864</a></td>
     <td>C++11</td>
     <td><I>braced-init-list</I> in the range-based <TT>for</TT> statement</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="865">
-    <td><a href="http://wg21.link/cwg865">865</a></td>
+    <td><a href="https://wg21.link/cwg865">865</a></td>
     <td>CD2</td>
     <td>Initializing a <TT>std::initializer_list</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="869">
-    <td><a href="http://wg21.link/cwg869">869</a></td>
+    <td><a href="https://wg21.link/cwg869">869</a></td>
     <td>CD2</td>
     <td>Uninitialized <TT>thread_local</TT> objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="872">
-    <td><a href="http://wg21.link/cwg872">872</a></td>
+    <td><a href="https://wg21.link/cwg872">872</a></td>
     <td>CD2</td>
     <td>Lexical issues with raw strings</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="873">
-    <td><a href="http://wg21.link/cwg873">873</a></td>
+    <td><a href="https://wg21.link/cwg873">873</a></td>
     <td>C++11</td>
     <td>Deducing rvalue references in declarative contexts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="874">
-    <td><a href="http://wg21.link/cwg874">874</a></td>
+    <td><a href="https://wg21.link/cwg874">874</a></td>
     <td>CD2</td>
     <td>Class-scope definitions of enumeration types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="876">
-    <td><a href="http://wg21.link/cwg876">876</a></td>
+    <td><a href="https://wg21.link/cwg876">876</a></td>
     <td>CD2</td>
     <td>Type references in rvalue reference deduction specification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="877">
-    <td><a href="http://wg21.link/cwg877">877</a></td>
+    <td><a href="https://wg21.link/cwg877">877</a></td>
     <td>CD2</td>
     <td>Viable functions and binding references to rvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="879">
-    <td><a href="http://wg21.link/cwg879">879</a></td>
+    <td><a href="https://wg21.link/cwg879">879</a></td>
     <td>CD2</td>
     <td>Missing built-in comparison operators for pointer types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="880">
-    <td><a href="http://wg21.link/cwg880">880</a></td>
+    <td><a href="https://wg21.link/cwg880">880</a></td>
     <td>CD2</td>
     <td>Built-in conditional operator for scoped enumerations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="882">
-    <td><a href="http://wg21.link/cwg882">882</a></td>
+    <td><a href="https://wg21.link/cwg882">882</a></td>
     <td>CD2</td>
     <td>Defining <TT>main</TT> as deleted</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="883">
-    <td><a href="http://wg21.link/cwg883">883</a></td>
+    <td><a href="https://wg21.link/cwg883">883</a></td>
     <td>CD2</td>
     <td><TT>std::memcpy</TT> vs <TT>std::memmove</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="884">
-    <td><a href="http://wg21.link/cwg884">884</a></td>
+    <td><a href="https://wg21.link/cwg884">884</a></td>
     <td>CD2</td>
     <td>Defining an explicitly-specialized static data member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="885">
-    <td><a href="http://wg21.link/cwg885">885</a></td>
+    <td><a href="https://wg21.link/cwg885">885</a></td>
     <td>NAD</td>
     <td>Partial ordering of function templates with unordered parameter pairs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="886">
-    <td><a href="http://wg21.link/cwg886">886</a></td>
+    <td><a href="https://wg21.link/cwg886">886</a></td>
     <td>CD2</td>
     <td>Member initializers and aggregates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="887">
-    <td><a href="http://wg21.link/cwg887">887</a></td>
+    <td><a href="https://wg21.link/cwg887">887</a></td>
     <td>CD2</td>
     <td>Move construction of thrown object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="888">
-    <td><a href="http://wg21.link/cwg888">888</a></td>
+    <td><a href="https://wg21.link/cwg888">888</a></td>
     <td>CD2</td>
     <td>Union member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="891">
-    <td><a href="http://wg21.link/cwg891">891</a></td>
+    <td><a href="https://wg21.link/cwg891">891</a></td>
     <td>CD2</td>
     <td><TT>const_cast</TT> to rvalue reference from objectless rvalue</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="892">
-    <td><a href="http://wg21.link/cwg892">892</a></td>
+    <td><a href="https://wg21.link/cwg892">892</a></td>
     <td>C++11</td>
     <td>Missing requirements for constexpr constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="893">
-    <td><a href="http://wg21.link/cwg893">893</a></td>
+    <td><a href="https://wg21.link/cwg893">893</a></td>
     <td>NAD</td>
     <td>Brace syntax for <I>enumerator-definition</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="896">
-    <td><a href="http://wg21.link/cwg896">896</a></td>
+    <td><a href="https://wg21.link/cwg896">896</a></td>
     <td>CD2</td>
     <td>Rvalue references and rvalue-reference conversion functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="897">
-    <td><a href="http://wg21.link/cwg897">897</a></td>
+    <td><a href="https://wg21.link/cwg897">897</a></td>
     <td>open</td>
     <td><TT>_Pragma</TT> and extended <I>string-literal</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="898">
-    <td><a href="http://wg21.link/cwg898">898</a></td>
+    <td><a href="https://wg21.link/cwg898">898</a></td>
     <td>C++11</td>
     <td>Declarations in constexpr functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="899">
-    <td><a href="http://wg21.link/cwg899">899</a></td>
+    <td><a href="https://wg21.link/cwg899">899</a></td>
     <td>CD2</td>
     <td>Explicit conversion functions in direct class initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="900">
-    <td><a href="http://wg21.link/cwg900">900</a></td>
+    <td><a href="https://wg21.link/cwg900">900</a></td>
     <td>extension</td>
     <td>Lifetime of temporaries in range-based <TT>for</TT></td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="901">
-    <td><a href="http://wg21.link/cwg901">901</a></td>
+    <td><a href="https://wg21.link/cwg901">901</a></td>
     <td>drafting</td>
     <td>Deleted <TT>operator delete</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="902">
-    <td><a href="http://wg21.link/cwg902">902</a></td>
+    <td><a href="https://wg21.link/cwg902">902</a></td>
     <td>NAD</td>
     <td>In-class initialization of non-constant static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="903">
-    <td><a href="http://wg21.link/cwg903">903</a></td>
+    <td><a href="https://wg21.link/cwg903">903</a></td>
     <td>CD3</td>
     <td>Value-dependent integral null pointer constants</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="904">
-    <td><a href="http://wg21.link/cwg904">904</a></td>
+    <td><a href="https://wg21.link/cwg904">904</a></td>
     <td>CD2</td>
     <td>Parameter packs in <I>lambda-capture</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="905">
-    <td><a href="http://wg21.link/cwg905">905</a></td>
+    <td><a href="https://wg21.link/cwg905">905</a></td>
     <td>CD2</td>
     <td>Explicit defaulted copy constructors and trivial copyability</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="906">
-    <td><a href="http://wg21.link/cwg906">906</a></td>
+    <td><a href="https://wg21.link/cwg906">906</a></td>
     <td>CD2</td>
     <td>Which special member functions can be defaulted?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="908">
-    <td><a href="http://wg21.link/cwg908">908</a></td>
+    <td><a href="https://wg21.link/cwg908">908</a></td>
     <td>CD2</td>
     <td>Deleted global allocation and deallocation functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="909">
-    <td><a href="http://wg21.link/cwg909">909</a></td>
+    <td><a href="https://wg21.link/cwg909">909</a></td>
     <td>NAD</td>
     <td>Old-style casts with conversion functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="910">
-    <td><a href="http://wg21.link/cwg910">910</a></td>
+    <td><a href="https://wg21.link/cwg910">910</a></td>
     <td>CD2</td>
     <td>Move constructors and implicitly-declared copy constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="912">
-    <td><a href="http://wg21.link/cwg912">912</a></td>
+    <td><a href="https://wg21.link/cwg912">912</a></td>
     <td>CD3</td>
     <td>Character literals and <I>universal-character-name</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="913">
-    <td><a href="http://wg21.link/cwg913">913</a></td>
+    <td><a href="https://wg21.link/cwg913">913</a></td>
     <td>CD2</td>
     <td>Deduction rules for array- and function-type conversion functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="914">
-    <td><a href="http://wg21.link/cwg914">914</a></td>
+    <td><a href="https://wg21.link/cwg914">914</a></td>
     <td>extension</td>
     <td>Value-initialization of array types</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="915">
-    <td><a href="http://wg21.link/cwg915">915</a></td>
+    <td><a href="https://wg21.link/cwg915">915</a></td>
     <td>CD2</td>
     <td>Deleted specializations of member function templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="916">
-    <td><a href="http://wg21.link/cwg916">916</a></td>
+    <td><a href="https://wg21.link/cwg916">916</a></td>
     <td>open</td>
     <td>Does a reference type have a destructor?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="919">
-    <td><a href="http://wg21.link/cwg919">919</a></td>
+    <td><a href="https://wg21.link/cwg919">919</a></td>
     <td>CD2</td>
     <td>Contradictions regarding inline namespaces</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="920">
-    <td><a href="http://wg21.link/cwg920">920</a></td>
+    <td><a href="https://wg21.link/cwg920">920</a></td>
     <td>CD2</td>
     <td>Interaction of inline namespaces and <I>using-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="921">
-    <td><a href="http://wg21.link/cwg921">921</a></td>
+    <td><a href="https://wg21.link/cwg921">921</a></td>
     <td>CD2</td>
     <td>Unclear specification of inline namespaces</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="922">
-    <td><a href="http://wg21.link/cwg922">922</a></td>
+    <td><a href="https://wg21.link/cwg922">922</a></td>
     <td>CD2</td>
     <td>Implicit default constructor definitions and <TT>const</TT> variant members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="923">
-    <td><a href="http://wg21.link/cwg923">923</a></td>
+    <td><a href="https://wg21.link/cwg923">923</a></td>
     <td>CD2</td>
     <td>Inline explicit specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="924">
-    <td><a href="http://wg21.link/cwg924">924</a></td>
+    <td><a href="https://wg21.link/cwg924">924</a></td>
     <td>C++11</td>
     <td><I>alias-declaration</I> as a class member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="925">
-    <td><a href="http://wg21.link/cwg925">925</a></td>
+    <td><a href="https://wg21.link/cwg925">925</a></td>
     <td>open</td>
     <td>Type of character literals in preprocessor expressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="926">
-    <td><a href="http://wg21.link/cwg926">926</a></td>
+    <td><a href="https://wg21.link/cwg926">926</a></td>
     <td>CD2</td>
     <td>Inline unnamed namespaces</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="927">
-    <td><a href="http://wg21.link/cwg927">927</a></td>
+    <td><a href="https://wg21.link/cwg927">927</a></td>
     <td>CD2</td>
     <td>Implicitly-deleted default constructors and member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="928">
-    <td><a href="http://wg21.link/cwg928">928</a></td>
+    <td><a href="https://wg21.link/cwg928">928</a></td>
     <td>CD2</td>
     <td>Defaulting a function that would be implicitly defined as deleted</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="929">
-    <td><a href="http://wg21.link/cwg929">929</a></td>
+    <td><a href="https://wg21.link/cwg929">929</a></td>
     <td>CD2</td>
     <td>What is a template alias?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="930">
-    <td><a href="http://wg21.link/cwg930">930</a></td>
+    <td><a href="https://wg21.link/cwg930">930</a></td>
     <td>CD2</td>
     <td><TT>alignof</TT> with incomplete array type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="931">
-    <td><a href="http://wg21.link/cwg931">931</a></td>
+    <td><a href="https://wg21.link/cwg931">931</a></td>
     <td>CD2</td>
     <td>Confusing reference to the length of a user-defined string literal</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="932">
-    <td><a href="http://wg21.link/cwg932">932</a></td>
+    <td><a href="https://wg21.link/cwg932">932</a></td>
     <td>CD2</td>
     <td>UCNs in closing delimiters of raw string literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="933">
-    <td><a href="http://wg21.link/cwg933">933</a></td>
+    <td><a href="https://wg21.link/cwg933">933</a></td>
     <td>CD2</td>
     <td>32-bit UCNs with 16-bit <TT>wchar_t</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="934">
-    <td><a href="http://wg21.link/cwg934">934</a></td>
+    <td><a href="https://wg21.link/cwg934">934</a></td>
     <td>CD2</td>
     <td>List-initialization of references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="935">
-    <td><a href="http://wg21.link/cwg935">935</a></td>
+    <td><a href="https://wg21.link/cwg935">935</a></td>
     <td>CD2</td>
     <td>Missing overloads for character types for user-defined literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="936">
-    <td><a href="http://wg21.link/cwg936">936</a></td>
+    <td><a href="https://wg21.link/cwg936">936</a></td>
     <td>CD2</td>
     <td>Array initialization with new string literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="937">
-    <td><a href="http://wg21.link/cwg937">937</a></td>
+    <td><a href="https://wg21.link/cwg937">937</a></td>
     <td>NAD</td>
     <td>Restrictions on values of template arguments in user-defined literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="938">
-    <td><a href="http://wg21.link/cwg938">938</a></td>
+    <td><a href="https://wg21.link/cwg938">938</a></td>
     <td>C++11</td>
     <td>Initializer lists and array new</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="939">
-    <td><a href="http://wg21.link/cwg939">939</a></td>
+    <td><a href="https://wg21.link/cwg939">939</a></td>
     <td>CD2</td>
     <td>Explicitly checking virtual function overriding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="940">
-    <td><a href="http://wg21.link/cwg940">940</a></td>
+    <td><a href="https://wg21.link/cwg940">940</a></td>
     <td>CD2</td>
     <td>Global anonymous unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="941">
-    <td><a href="http://wg21.link/cwg941">941</a></td>
+    <td><a href="https://wg21.link/cwg941">941</a></td>
     <td>C++11</td>
     <td>Explicit specialization of deleted function template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="942">
-    <td><a href="http://wg21.link/cwg942">942</a></td>
+    <td><a href="https://wg21.link/cwg942">942</a></td>
     <td>CD2</td>
     <td>Is <TT>this</TT> an entity?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="943">
-    <td><a href="http://wg21.link/cwg943">943</a></td>
+    <td><a href="https://wg21.link/cwg943">943</a></td>
     <td>DRWP</td>
     <td>Is <TT>T()</TT> a temporary?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="944">
-    <td><a href="http://wg21.link/cwg944">944</a></td>
+    <td><a href="https://wg21.link/cwg944">944</a></td>
     <td>extension</td>
     <td><TT>reinterpret_cast</TT> for all types with the same size and alignment</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="945">
-    <td><a href="http://wg21.link/cwg945">945</a></td>
+    <td><a href="https://wg21.link/cwg945">945</a></td>
     <td>C++11</td>
     <td>Use of <TT>this</TT> in a late-specified return type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="946">
-    <td><a href="http://wg21.link/cwg946">946</a></td>
+    <td><a href="https://wg21.link/cwg946">946</a></td>
     <td>CD2</td>
     <td>Order of destruction of local static objects and calls to <TT>std::atexit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="947">
-    <td><a href="http://wg21.link/cwg947">947</a></td>
+    <td><a href="https://wg21.link/cwg947">947</a></td>
     <td>NAD</td>
     <td>Deducing type template arguments from default function arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="948">
-    <td><a href="http://wg21.link/cwg948">948</a></td>
+    <td><a href="https://wg21.link/cwg948">948</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> in <I>condition</I>s</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr class="open" id="949">
-    <td><a href="http://wg21.link/cwg949">949</a></td>
+    <td><a href="https://wg21.link/cwg949">949</a></td>
     <td>open</td>
     <td>Requirements for freestanding implementations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="950">
-    <td><a href="http://wg21.link/cwg950">950</a></td>
+    <td><a href="https://wg21.link/cwg950">950</a></td>
     <td>CD2</td>
     <td>Use of <TT>decltype</TT> as a <I>class-name</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="951">
-    <td><a href="http://wg21.link/cwg951">951</a></td>
+    <td><a href="https://wg21.link/cwg951">951</a></td>
     <td>CD2</td>
     <td>Problems with <I>attribute-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="952">
-    <td><a href="http://wg21.link/cwg952">952</a></td>
+    <td><a href="https://wg21.link/cwg952">952</a></td>
     <td>drafting</td>
     <td>Insufficient description of &#8220;naming class&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="953">
-    <td><a href="http://wg21.link/cwg953">953</a></td>
+    <td><a href="https://wg21.link/cwg953">953</a></td>
     <td>CD2</td>
     <td>Rvalue references and function viability</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="954">
-    <td><a href="http://wg21.link/cwg954">954</a></td>
+    <td><a href="https://wg21.link/cwg954">954</a></td>
     <td>open</td>
     <td>Overload resolution of conversion operator templates with built-in types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="955">
-    <td><a href="http://wg21.link/cwg955">955</a></td>
+    <td><a href="https://wg21.link/cwg955">955</a></td>
     <td>CD2</td>
     <td>Can a closure type's <TT>operator()</TT> be virtual?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="956">
-    <td><a href="http://wg21.link/cwg956">956</a></td>
+    <td><a href="https://wg21.link/cwg956">956</a></td>
     <td>CD2</td>
     <td>Function prototype scope with late-specified return types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="957">
-    <td><a href="http://wg21.link/cwg957">957</a></td>
+    <td><a href="https://wg21.link/cwg957">957</a></td>
     <td>CD2</td>
     <td>Alternative tokens and <I>attribute-token</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="958">
-    <td><a href="http://wg21.link/cwg958">958</a></td>
+    <td><a href="https://wg21.link/cwg958">958</a></td>
     <td>NAD</td>
     <td>Lambdas and <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="959">
-    <td><a href="http://wg21.link/cwg959">959</a></td>
+    <td><a href="https://wg21.link/cwg959">959</a></td>
     <td>CD2</td>
     <td>Alignment attribute for class and enumeration types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="960">
-    <td><a href="http://wg21.link/cwg960">960</a></td>
+    <td><a href="https://wg21.link/cwg960">960</a></td>
     <td>CD2</td>
     <td>Covariant functions and lvalue/rvalue references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="961">
-    <td><a href="http://wg21.link/cwg961">961</a></td>
+    <td><a href="https://wg21.link/cwg961">961</a></td>
     <td>CD2</td>
     <td>Overload resolution and conversion of <TT>std::nullptr_t</TT> to <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="962">
-    <td><a href="http://wg21.link/cwg962">962</a></td>
+    <td><a href="https://wg21.link/cwg962">962</a></td>
     <td>CD2</td>
     <td>Attributes appertaining to class and enum types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="963">
-    <td><a href="http://wg21.link/cwg963">963</a></td>
+    <td><a href="https://wg21.link/cwg963">963</a></td>
     <td>CD2</td>
     <td>Comparing <TT>nullptr</TT> with 0</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="964">
-    <td><a href="http://wg21.link/cwg964">964</a></td>
+    <td><a href="https://wg21.link/cwg964">964</a></td>
     <td>C++11</td>
     <td>Incorrect description of when the lvalue-to-rvalue conversion applies</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="965">
-    <td><a href="http://wg21.link/cwg965">965</a></td>
+    <td><a href="https://wg21.link/cwg965">965</a></td>
     <td>CD2</td>
     <td>Limiting the applicability of the <TT>carries_dependency</TT> attribute</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="966">
-    <td><a href="http://wg21.link/cwg966">966</a></td>
+    <td><a href="https://wg21.link/cwg966">966</a></td>
     <td>CD2</td>
     <td>Nested types without linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="967">
-    <td><a href="http://wg21.link/cwg967">967</a></td>
+    <td><a href="https://wg21.link/cwg967">967</a></td>
     <td>NAD</td>
     <td>Exception specification of replacement allocation function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="968">
-    <td><a href="http://wg21.link/cwg968">968</a></td>
+    <td><a href="https://wg21.link/cwg968">968</a></td>
     <td>CD2</td>
     <td>Syntactic ambiguity of the attribute notation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="969">
-    <td><a href="http://wg21.link/cwg969">969</a></td>
+    <td><a href="https://wg21.link/cwg969">969</a></td>
     <td>CD2</td>
     <td>Explicit instantiation declarations of class template specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="970">
-    <td><a href="http://wg21.link/cwg970">970</a></td>
+    <td><a href="https://wg21.link/cwg970">970</a></td>
     <td>CD2</td>
     <td>Consistent use of &#8220;appertain&#8221; and &#8220;apply&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="971">
-    <td><a href="http://wg21.link/cwg971">971</a></td>
+    <td><a href="https://wg21.link/cwg971">971</a></td>
     <td>C++11</td>
     <td>Incorrect treatment of <I>exception-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="972">
-    <td><a href="http://wg21.link/cwg972">972</a></td>
+    <td><a href="https://wg21.link/cwg972">972</a></td>
     <td>C++11</td>
     <td>Allowing multiple <I>attribute-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="973">
-    <td><a href="http://wg21.link/cwg973">973</a></td>
+    <td><a href="https://wg21.link/cwg973">973</a></td>
     <td>CD2</td>
     <td>Function types in <I>exception-specification</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="974">
-    <td><a href="http://wg21.link/cwg974">974</a></td>
+    <td><a href="https://wg21.link/cwg974">974</a></td>
     <td>CD3</td>
     <td>Default arguments for lambdas</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="975">
-    <td><a href="http://wg21.link/cwg975">975</a></td>
+    <td><a href="https://wg21.link/cwg975">975</a></td>
     <td>CD3</td>
     <td>Restrictions on return type deduction for lambdas</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="976">
-    <td><a href="http://wg21.link/cwg976">976</a></td>
+    <td><a href="https://wg21.link/cwg976">976</a></td>
     <td>CD2</td>
     <td>Deduction for <TT>const T&amp;</TT> conversion operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="977">
-    <td><a href="http://wg21.link/cwg977">977</a></td>
+    <td><a href="https://wg21.link/cwg977">977</a></td>
     <td>CD3</td>
     <td>When is an enumeration type complete?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="978">
-    <td><a href="http://wg21.link/cwg978">978</a></td>
+    <td><a href="https://wg21.link/cwg978">978</a></td>
     <td>CD2</td>
     <td>Incorrect specification for copy initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="979">
-    <td><a href="http://wg21.link/cwg979">979</a></td>
+    <td><a href="https://wg21.link/cwg979">979</a></td>
     <td>CD2</td>
     <td>Position of <I>attribute-specifier</I> in declarator syntax</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="980">
-    <td><a href="http://wg21.link/cwg980">980</a></td>
+    <td><a href="https://wg21.link/cwg980">980</a></td>
     <td>CD2</td>
     <td>Explicit instantiation of a member of a class template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="981">
-    <td><a href="http://wg21.link/cwg981">981</a></td>
+    <td><a href="https://wg21.link/cwg981">981</a></td>
     <td>C++11</td>
     <td>Constexpr constructor templates and literal types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="982">
-    <td><a href="http://wg21.link/cwg982">982</a></td>
+    <td><a href="https://wg21.link/cwg982">982</a></td>
     <td>NAD</td>
     <td>Initialization with an empty initializer list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="983">
-    <td><a href="http://wg21.link/cwg983">983</a></td>
+    <td><a href="https://wg21.link/cwg983">983</a></td>
     <td>CD2</td>
     <td>Ambiguous pointer-to-member constant</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="984">
-    <td><a href="http://wg21.link/cwg984">984</a></td>
+    <td><a href="https://wg21.link/cwg984">984</a></td>
     <td>CD2</td>
     <td>&#8220;Deduced type&#8221; is unclear in <TT>auto</TT> type deduction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="985">
-    <td><a href="http://wg21.link/cwg985">985</a></td>
+    <td><a href="https://wg21.link/cwg985">985</a></td>
     <td>C++11</td>
     <td>Alternative tokens and user-defined literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="986">
-    <td><a href="http://wg21.link/cwg986">986</a></td>
+    <td><a href="https://wg21.link/cwg986">986</a></td>
     <td>CD2</td>
     <td>Transitivity of <I>using-directive</I>s versus qualified lookup</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="987">
-    <td><a href="http://wg21.link/cwg987">987</a></td>
+    <td><a href="https://wg21.link/cwg987">987</a></td>
     <td>CD4</td>
     <td>Which declarations introduce namespace members?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="988">
-    <td><a href="http://wg21.link/cwg988">988</a></td>
+    <td><a href="https://wg21.link/cwg988">988</a></td>
     <td>CD2</td>
     <td>Reference-to-reference collapsing with <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="989">
-    <td><a href="http://wg21.link/cwg989">989</a></td>
+    <td><a href="https://wg21.link/cwg989">989</a></td>
     <td>CD2</td>
     <td>Misplaced list-initialization example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="990">
-    <td><a href="http://wg21.link/cwg990">990</a></td>
+    <td><a href="https://wg21.link/cwg990">990</a></td>
     <td>CD2</td>
     <td>Value initialization with multiple initializer-list constructors</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="991">
-    <td><a href="http://wg21.link/cwg991">991</a></td>
+    <td><a href="https://wg21.link/cwg991">991</a></td>
     <td>CD2</td>
     <td>Reference parameters of constexpr functions and constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="992">
-    <td><a href="http://wg21.link/cwg992">992</a></td>
+    <td><a href="https://wg21.link/cwg992">992</a></td>
     <td>NAD</td>
     <td>Inheriting explicitness</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="993">
-    <td><a href="http://wg21.link/cwg993">993</a></td>
+    <td><a href="https://wg21.link/cwg993">993</a></td>
     <td>C++11</td>
     <td>Freedom to perform instantiation at the end of the translation unit</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="994">
-    <td><a href="http://wg21.link/cwg994">994</a></td>
+    <td><a href="https://wg21.link/cwg994">994</a></td>
     <td>C++11</td>
     <td><I>braced-init-list</I> as a default argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="995">
-    <td><a href="http://wg21.link/cwg995">995</a></td>
+    <td><a href="https://wg21.link/cwg995">995</a></td>
     <td>CD2</td>
     <td>Incorrect example for <I>using-declaration</I> and explicit instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="996">
-    <td><a href="http://wg21.link/cwg996">996</a></td>
+    <td><a href="https://wg21.link/cwg996">996</a></td>
     <td>C++11</td>
     <td>Ambiguous partial specializations of member class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="997">
-    <td><a href="http://wg21.link/cwg997">997</a></td>
+    <td><a href="https://wg21.link/cwg997">997</a></td>
     <td>C++11</td>
     <td>Argument-dependent lookup and dependent function template parameter types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="998">
-    <td><a href="http://wg21.link/cwg998">998</a></td>
+    <td><a href="https://wg21.link/cwg998">998</a></td>
     <td>dup</td>
     <td>Function parameter transformations and template functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="999">
-    <td><a href="http://wg21.link/cwg999">999</a></td>
+    <td><a href="https://wg21.link/cwg999">999</a></td>
     <td>CD2</td>
     <td>&#8220;Implicit&#8221; or &#8220;implied&#8221; object argument/parameter?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1000">
-    <td><a href="http://wg21.link/cwg1000">1000</a></td>
+    <td><a href="https://wg21.link/cwg1000">1000</a></td>
     <td>CD2</td>
     <td>Mistaking member typedefs for constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1001">
-    <td><a href="http://wg21.link/cwg1001">1001</a></td>
+    <td><a href="https://wg21.link/cwg1001">1001</a></td>
     <td>drafting</td>
     <td>Parameter type adjustment in dependent parameter types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1002">
-    <td><a href="http://wg21.link/cwg1002">1002</a></td>
+    <td><a href="https://wg21.link/cwg1002">1002</a></td>
     <td>NAD</td>
     <td>Pack expansion for function arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1003">
-    <td><a href="http://wg21.link/cwg1003">1003</a></td>
+    <td><a href="https://wg21.link/cwg1003">1003</a></td>
     <td>CD3</td>
     <td>Acceptable definitions of <TT>main</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1004">
-    <td><a href="http://wg21.link/cwg1004">1004</a></td>
+    <td><a href="https://wg21.link/cwg1004">1004</a></td>
     <td>C++11</td>
     <td>Injected-class-names as arguments for template template parameters</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr id="1005">
-    <td><a href="http://wg21.link/cwg1005">1005</a></td>
+    <td><a href="https://wg21.link/cwg1005">1005</a></td>
     <td>NAD</td>
     <td>Qualified name resolution in member functions of class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1006">
-    <td><a href="http://wg21.link/cwg1006">1006</a></td>
+    <td><a href="https://wg21.link/cwg1006">1006</a></td>
     <td>C++11</td>
     <td><TT>std::nullptr_t</TT> as a non-type template parameter</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1007">
-    <td><a href="http://wg21.link/cwg1007">1007</a></td>
+    <td><a href="https://wg21.link/cwg1007">1007</a></td>
     <td>NAD</td>
     <td>Protected access and pointers to members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1008">
-    <td><a href="http://wg21.link/cwg1008">1008</a></td>
+    <td><a href="https://wg21.link/cwg1008">1008</a></td>
     <td>extension</td>
     <td>Querying the alignment of an object</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1009">
-    <td><a href="http://wg21.link/cwg1009">1009</a></td>
+    <td><a href="https://wg21.link/cwg1009">1009</a></td>
     <td>C++11</td>
     <td>Missing cases in the <I>declarator-id</I> of a function template declaration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1010">
-    <td><a href="http://wg21.link/cwg1010">1010</a></td>
+    <td><a href="https://wg21.link/cwg1010">1010</a></td>
     <td>CD2</td>
     <td>Address of object with dynamic storage duration in constant expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1011">
-    <td><a href="http://wg21.link/cwg1011">1011</a></td>
+    <td><a href="https://wg21.link/cwg1011">1011</a></td>
     <td>C++11</td>
     <td>Standard conversions that cannot be inverted</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1012">
-    <td><a href="http://wg21.link/cwg1012">1012</a></td>
+    <td><a href="https://wg21.link/cwg1012">1012</a></td>
     <td>C++11</td>
     <td>Undeprecating <TT>static</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1013">
-    <td><a href="http://wg21.link/cwg1013">1013</a></td>
+    <td><a href="https://wg21.link/cwg1013">1013</a></td>
     <td>CD3</td>
     <td>Uninitialized <TT>std::nullptr_t</TT> objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1014">
-    <td><a href="http://wg21.link/cwg1014">1014</a></td>
+    <td><a href="https://wg21.link/cwg1014">1014</a></td>
     <td>NAD</td>
     <td>Overload resolution between <TT>const T&amp;</TT> and <TT>T&amp;&amp;</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1015">
-    <td><a href="http://wg21.link/cwg1015">1015</a></td>
+    <td><a href="https://wg21.link/cwg1015">1015</a></td>
     <td>C++11</td>
     <td>Template arguments and argument-dependent lookup</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1016">
-    <td><a href="http://wg21.link/cwg1016">1016</a></td>
+    <td><a href="https://wg21.link/cwg1016">1016</a></td>
     <td>C++11</td>
     <td>Overloadable declarations, function templates, and references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1017">
-    <td><a href="http://wg21.link/cwg1017">1017</a></td>
+    <td><a href="https://wg21.link/cwg1017">1017</a></td>
     <td>C++11</td>
     <td>Member access transformation in unevaluated operands</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1018">
-    <td><a href="http://wg21.link/cwg1018">1018</a></td>
+    <td><a href="https://wg21.link/cwg1018">1018</a></td>
     <td>C++11</td>
     <td>Ambiguity between <I>simple-declaration</I> and <I>attribute-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1019">
-    <td><a href="http://wg21.link/cwg1019">1019</a></td>
+    <td><a href="https://wg21.link/cwg1019">1019</a></td>
     <td>dup</td>
     <td>Dependent <I>simple-template-id</I>s in <I>base-specifier</I>s and <I>mem-initializer</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1020">
-    <td><a href="http://wg21.link/cwg1020">1020</a></td>
+    <td><a href="https://wg21.link/cwg1020">1020</a></td>
     <td>C++11</td>
     <td>Implicitly-defined copy constructors and explicit base class constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1021">
-    <td><a href="http://wg21.link/cwg1021">1021</a></td>
+    <td><a href="https://wg21.link/cwg1021">1021</a></td>
     <td>CD4</td>
     <td>Definitions of namespace members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1022">
-    <td><a href="http://wg21.link/cwg1022">1022</a></td>
+    <td><a href="https://wg21.link/cwg1022">1022</a></td>
     <td>C++11</td>
     <td>Can an enumeration variable have values outside the values of the enumeration?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1023">
-    <td><a href="http://wg21.link/cwg1023">1023</a></td>
+    <td><a href="https://wg21.link/cwg1023">1023</a></td>
     <td>dup</td>
     <td><TT>thread_local</TT> objects as non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1024">
-    <td><a href="http://wg21.link/cwg1024">1024</a></td>
+    <td><a href="https://wg21.link/cwg1024">1024</a></td>
     <td>CD3</td>
     <td>Limits on multicharacter literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1025">
-    <td><a href="http://wg21.link/cwg1025">1025</a></td>
+    <td><a href="https://wg21.link/cwg1025">1025</a></td>
     <td>C++11</td>
     <td>Use of a reference as a non-type template argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1026">
-    <td><a href="http://wg21.link/cwg1026">1026</a></td>
+    <td><a href="https://wg21.link/cwg1026">1026</a></td>
     <td>NAD</td>
     <td>Cv-qualified non-class rvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1027">
-    <td><a href="http://wg21.link/cwg1027">1027</a></td>
+    <td><a href="https://wg21.link/cwg1027">1027</a></td>
     <td>drafting</td>
     <td>Type consistency and reallocation of scalar types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1028">
-    <td><a href="http://wg21.link/cwg1028">1028</a></td>
+    <td><a href="https://wg21.link/cwg1028">1028</a></td>
     <td>open</td>
     <td>Dependent names in non-defining declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1029">
-    <td><a href="http://wg21.link/cwg1029">1029</a></td>
+    <td><a href="https://wg21.link/cwg1029">1029</a></td>
     <td>C++11</td>
     <td>Type of a destructor call</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1030">
-    <td><a href="http://wg21.link/cwg1030">1030</a></td>
+    <td><a href="https://wg21.link/cwg1030">1030</a></td>
     <td>C++11</td>
     <td>Evaluation order in <I>initializer-list</I>s used in aggregate initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1031">
-    <td><a href="http://wg21.link/cwg1031">1031</a></td>
+    <td><a href="https://wg21.link/cwg1031">1031</a></td>
     <td>C++11</td>
     <td>Optional elements in attributes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1032">
-    <td><a href="http://wg21.link/cwg1032">1032</a></td>
+    <td><a href="https://wg21.link/cwg1032">1032</a></td>
     <td>C++11</td>
     <td>Empty pack expansions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1033">
-    <td><a href="http://wg21.link/cwg1033">1033</a></td>
+    <td><a href="https://wg21.link/cwg1033">1033</a></td>
     <td>C++11</td>
     <td>Restrictions on alignment attributes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1034">
-    <td><a href="http://wg21.link/cwg1034">1034</a></td>
+    <td><a href="https://wg21.link/cwg1034">1034</a></td>
     <td>C++11</td>
     <td>Attributes for <TT>return</TT> statements in lambdas</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1035">
-    <td><a href="http://wg21.link/cwg1035">1035</a></td>
+    <td><a href="https://wg21.link/cwg1035">1035</a></td>
     <td>C++11</td>
     <td>Omitted and required <I>decl-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1036">
-    <td><a href="http://wg21.link/cwg1036">1036</a></td>
+    <td><a href="https://wg21.link/cwg1036">1036</a></td>
     <td>C++11</td>
     <td>Alignment attribute in an <I>exception-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1037">
-    <td><a href="http://wg21.link/cwg1037">1037</a></td>
+    <td><a href="https://wg21.link/cwg1037">1037</a></td>
     <td>C++11</td>
     <td>Requirements for operands of <I>delete-expression</I>s and deallocation functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1038">
-    <td><a href="http://wg21.link/cwg1038">1038</a></td>
+    <td><a href="https://wg21.link/cwg1038">1038</a></td>
     <td>open</td>
     <td>Overload resolution of <TT>&amp;x.static_func</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1039">
-    <td><a href="http://wg21.link/cwg1039">1039</a></td>
+    <td><a href="https://wg21.link/cwg1039">1039</a></td>
     <td>dup</td>
     <td>Coordinating C and C++ alignment specifications</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1040">
-    <td><a href="http://wg21.link/cwg1040">1040</a></td>
+    <td><a href="https://wg21.link/cwg1040">1040</a></td>
     <td>NAD</td>
     <td>Memory model issues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1041">
-    <td><a href="http://wg21.link/cwg1041">1041</a></td>
+    <td><a href="https://wg21.link/cwg1041">1041</a></td>
     <td>dup</td>
     <td><I>alias-declaration</I>s as class members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1042">
-    <td><a href="http://wg21.link/cwg1042">1042</a></td>
+    <td><a href="https://wg21.link/cwg1042">1042</a></td>
     <td>C++11</td>
     <td>Attributes in <I>alias-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1043">
-    <td><a href="http://wg21.link/cwg1043">1043</a></td>
+    <td><a href="https://wg21.link/cwg1043">1043</a></td>
     <td>C++11</td>
     <td>Qualified name lookup in the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1044">
-    <td><a href="http://wg21.link/cwg1044">1044</a></td>
+    <td><a href="https://wg21.link/cwg1044">1044</a></td>
     <td>C++11</td>
     <td>Point of declaration for an <I>alias-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1045">
-    <td><a href="http://wg21.link/cwg1045">1045</a></td>
+    <td><a href="https://wg21.link/cwg1045">1045</a></td>
     <td>NAD</td>
     <td>Requiring explicit instantiation declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1046">
-    <td><a href="http://wg21.link/cwg1046">1046</a></td>
+    <td><a href="https://wg21.link/cwg1046">1046</a></td>
     <td>open</td>
     <td>What is a &#8220;use&#8221; of a class specialization?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1047">
-    <td><a href="http://wg21.link/cwg1047">1047</a></td>
+    <td><a href="https://wg21.link/cwg1047">1047</a></td>
     <td>C++11</td>
     <td>When is <TT>typeid</TT> value-dependent?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1048">
-    <td><a href="http://wg21.link/cwg1048">1048</a></td>
+    <td><a href="https://wg21.link/cwg1048">1048</a></td>
     <td>CD3</td>
     <td><TT>auto</TT> deduction and lambda return type deduction.</td>
     <td class="full" align="center">Clang 3.6</td>
   </tr>
   <tr class="open" id="1049">
-    <td><a href="http://wg21.link/cwg1049">1049</a></td>
+    <td><a href="https://wg21.link/cwg1049">1049</a></td>
     <td>open</td>
     <td>Copy elision through reference parameters of inline functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1050">
-    <td><a href="http://wg21.link/cwg1050">1050</a></td>
+    <td><a href="https://wg21.link/cwg1050">1050</a></td>
     <td>NAD</td>
     <td>Effects of thread support on object lifetime</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1051">
-    <td><a href="http://wg21.link/cwg1051">1051</a></td>
+    <td><a href="https://wg21.link/cwg1051">1051</a></td>
     <td>C++11</td>
     <td>Reference members and generated copy constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1052">
-    <td><a href="http://wg21.link/cwg1052">1052</a></td>
+    <td><a href="https://wg21.link/cwg1052">1052</a></td>
     <td>dup</td>
     <td><TT>const</TT> non-static data member and PODness</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1053">
-    <td><a href="http://wg21.link/cwg1053">1053</a></td>
+    <td><a href="https://wg21.link/cwg1053">1053</a></td>
     <td>NAD</td>
     <td>Terminate vs undefined behavior for noexcept violation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1054">
-    <td><a href="http://wg21.link/cwg1054">1054</a></td>
+    <td><a href="https://wg21.link/cwg1054">1054</a></td>
     <td>C++11</td>
     <td>Lvalue-to-rvalue conversions in expression statements</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="1055">
-    <td><a href="http://wg21.link/cwg1055">1055</a></td>
+    <td><a href="https://wg21.link/cwg1055">1055</a></td>
     <td>C++11</td>
     <td>Permissible uses of <TT>void</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1056">
-    <td><a href="http://wg21.link/cwg1056">1056</a></td>
+    <td><a href="https://wg21.link/cwg1056">1056</a></td>
     <td>C++11</td>
     <td>Template aliases, member definitions, and the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1057">
-    <td><a href="http://wg21.link/cwg1057">1057</a></td>
+    <td><a href="https://wg21.link/cwg1057">1057</a></td>
     <td>C++11</td>
     <td><TT>decltype</TT> and the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1058">
-    <td><a href="http://wg21.link/cwg1058">1058</a></td>
+    <td><a href="https://wg21.link/cwg1058">1058</a></td>
     <td>NAD</td>
     <td>Reference binding of incompatible array types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1059">
-    <td><a href="http://wg21.link/cwg1059">1059</a></td>
+    <td><a href="https://wg21.link/cwg1059">1059</a></td>
     <td>CD3</td>
     <td>Cv-qualified array types (with rvalues)</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1060">
-    <td><a href="http://wg21.link/cwg1060">1060</a></td>
+    <td><a href="https://wg21.link/cwg1060">1060</a></td>
     <td>C++11</td>
     <td>Scoped enumerators in integral constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1061">
-    <td><a href="http://wg21.link/cwg1061">1061</a></td>
+    <td><a href="https://wg21.link/cwg1061">1061</a></td>
     <td>C++11</td>
     <td>Negative array bounds in a <I>new-expression</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1062">
-    <td><a href="http://wg21.link/cwg1062">1062</a></td>
+    <td><a href="https://wg21.link/cwg1062">1062</a></td>
     <td>C++11</td>
     <td>Syntax of <I>attribute-specifier</I>s in lambdas</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1063">
-    <td><a href="http://wg21.link/cwg1063">1063</a></td>
+    <td><a href="https://wg21.link/cwg1063">1063</a></td>
     <td>C++11</td>
     <td><TT>[[hiding]]</TT> with non-attribute declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1064">
-    <td><a href="http://wg21.link/cwg1064">1064</a></td>
+    <td><a href="https://wg21.link/cwg1064">1064</a></td>
     <td>C++11</td>
     <td>Defaulted move constructor for a union</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1065">
-    <td><a href="http://wg21.link/cwg1065">1065</a></td>
+    <td><a href="https://wg21.link/cwg1065">1065</a></td>
     <td>C++11</td>
     <td><TT>[[hiding]]</TT> with <TT>[[override]]</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1066">
-    <td><a href="http://wg21.link/cwg1066">1066</a></td>
+    <td><a href="https://wg21.link/cwg1066">1066</a></td>
     <td>C++11</td>
     <td>When is a copy/move assignment operator implicitly defined?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1067">
-    <td><a href="http://wg21.link/cwg1067">1067</a></td>
+    <td><a href="https://wg21.link/cwg1067">1067</a></td>
     <td>NAD</td>
     <td><TT>[[hiding]]</TT>, <I>using-declaration</I>s, and multiple inheritance</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1068">
-    <td><a href="http://wg21.link/cwg1068">1068</a></td>
+    <td><a href="https://wg21.link/cwg1068">1068</a></td>
     <td>C++11</td>
     <td>Template aliases with default arguments and template parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1069">
-    <td><a href="http://wg21.link/cwg1069">1069</a></td>
+    <td><a href="https://wg21.link/cwg1069">1069</a></td>
     <td>C++11</td>
     <td>Incorrect function type with <I>trailing-return-type</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1070">
-    <td><a href="http://wg21.link/cwg1070">1070</a></td>
+    <td><a href="https://wg21.link/cwg1070">1070</a></td>
     <td>C++11</td>
     <td>Missing initializer clauses in aggregate initialization</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="1071">
-    <td><a href="http://wg21.link/cwg1071">1071</a></td>
+    <td><a href="https://wg21.link/cwg1071">1071</a></td>
     <td>C++11</td>
     <td>Literal class types and trivial default constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1072">
-    <td><a href="http://wg21.link/cwg1072">1072</a></td>
+    <td><a href="https://wg21.link/cwg1072">1072</a></td>
     <td>C++11</td>
     <td>Scoped enumerator with the same name as its containing class</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1073">
-    <td><a href="http://wg21.link/cwg1073">1073</a></td>
+    <td><a href="https://wg21.link/cwg1073">1073</a></td>
     <td>C++11</td>
     <td>Merging <I>dynamic-exception-specification</I>s and <I>noexcept-specification</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1074">
-    <td><a href="http://wg21.link/cwg1074">1074</a></td>
+    <td><a href="https://wg21.link/cwg1074">1074</a></td>
     <td>C++11</td>
     <td>Value-dependent <I>noexcept-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1075">
-    <td><a href="http://wg21.link/cwg1075">1075</a></td>
+    <td><a href="https://wg21.link/cwg1075">1075</a></td>
     <td>C++11</td>
     <td>Grammar does not allow template alias in <I>type-name</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1076">
-    <td><a href="http://wg21.link/cwg1076">1076</a></td>
+    <td><a href="https://wg21.link/cwg1076">1076</a></td>
     <td>DRWP</td>
     <td>Value categories and lvalue temporaries</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1077">
-    <td><a href="http://wg21.link/cwg1077">1077</a></td>
+    <td><a href="https://wg21.link/cwg1077">1077</a></td>
     <td>extension</td>
     <td>Explicit specializations in non-containing namespaces</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1078">
-    <td><a href="http://wg21.link/cwg1078">1078</a></td>
+    <td><a href="https://wg21.link/cwg1078">1078</a></td>
     <td>NAD</td>
     <td>Narrowing and the usual arithmetic conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1079">
-    <td><a href="http://wg21.link/cwg1079">1079</a></td>
+    <td><a href="https://wg21.link/cwg1079">1079</a></td>
     <td>C++11</td>
     <td>Overload resolution involving aggregate initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1080">
-    <td><a href="http://wg21.link/cwg1080">1080</a></td>
+    <td><a href="https://wg21.link/cwg1080">1080</a></td>
     <td>C++11</td>
     <td>Confusing relationship between templates and copy constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1081">
-    <td><a href="http://wg21.link/cwg1081">1081</a></td>
+    <td><a href="https://wg21.link/cwg1081">1081</a></td>
     <td>C++11</td>
     <td>Defaulted destructor and unusable operator delete</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1082">
-    <td><a href="http://wg21.link/cwg1082">1082</a></td>
+    <td><a href="https://wg21.link/cwg1082">1082</a></td>
     <td>C++11</td>
     <td>Implicit copy function if subobject has none?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1083">
-    <td><a href="http://wg21.link/cwg1083">1083</a></td>
+    <td><a href="https://wg21.link/cwg1083">1083</a></td>
     <td>C++11</td>
     <td>Passing an object to ellipsis with non-trivial move constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1084">
-    <td><a href="http://wg21.link/cwg1084">1084</a></td>
+    <td><a href="https://wg21.link/cwg1084">1084</a></td>
     <td>NAD</td>
     <td>Conditions for a deleted move function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1085">
-    <td><a href="http://wg21.link/cwg1085">1085</a></td>
+    <td><a href="https://wg21.link/cwg1085">1085</a></td>
     <td>NAD</td>
     <td>Move assignment operators and virtual bases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1086">
-    <td><a href="http://wg21.link/cwg1086">1086</a></td>
+    <td><a href="https://wg21.link/cwg1086">1086</a></td>
     <td>C++11</td>
     <td><TT>const_cast</TT> to rvalue reference to function type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1087">
-    <td><a href="http://wg21.link/cwg1087">1087</a></td>
+    <td><a href="https://wg21.link/cwg1087">1087</a></td>
     <td>C++11</td>
     <td>Additional applications of issue 899</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1088">
-    <td><a href="http://wg21.link/cwg1088">1088</a></td>
+    <td><a href="https://wg21.link/cwg1088">1088</a></td>
     <td>C++11</td>
     <td>Dependent non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1089">
-    <td><a href="http://wg21.link/cwg1089">1089</a></td>
+    <td><a href="https://wg21.link/cwg1089">1089</a></td>
     <td>drafting</td>
     <td>Template parameters in member selections</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1090">
-    <td><a href="http://wg21.link/cwg1090">1090</a></td>
+    <td><a href="https://wg21.link/cwg1090">1090</a></td>
     <td>C++11</td>
     <td>Alignment of subobjects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1091">
-    <td><a href="http://wg21.link/cwg1091">1091</a></td>
+    <td><a href="https://wg21.link/cwg1091">1091</a></td>
     <td>C++11</td>
     <td>Inconsistent use of the term &#8220;object expression&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1092">
-    <td><a href="http://wg21.link/cwg1092">1092</a></td>
+    <td><a href="https://wg21.link/cwg1092">1092</a></td>
     <td>drafting</td>
     <td>Cycles in overload resolution during instantiation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1093">
-    <td><a href="http://wg21.link/cwg1093">1093</a></td>
+    <td><a href="https://wg21.link/cwg1093">1093</a></td>
     <td>CD3</td>
     <td>Value-initializing non-objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1094">
-    <td><a href="http://wg21.link/cwg1094">1094</a></td>
+    <td><a href="https://wg21.link/cwg1094">1094</a></td>
     <td>C++11</td>
     <td>Converting floating-point values to scoped enumeration types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1095">
-    <td><a href="http://wg21.link/cwg1095">1095</a></td>
+    <td><a href="https://wg21.link/cwg1095">1095</a></td>
     <td>C++11</td>
     <td>List-initialization of references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1096">
-    <td><a href="http://wg21.link/cwg1096">1096</a></td>
+    <td><a href="https://wg21.link/cwg1096">1096</a></td>
     <td>C++11</td>
     <td>Missing requirement for template definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1097">
-    <td><a href="http://wg21.link/cwg1097">1097</a></td>
+    <td><a href="https://wg21.link/cwg1097">1097</a></td>
     <td>NAD</td>
     <td>Aggregate initialization of function parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1098">
-    <td><a href="http://wg21.link/cwg1098">1098</a></td>
+    <td><a href="https://wg21.link/cwg1098">1098</a></td>
     <td>C++11</td>
     <td>Pointer conversions in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1099">
-    <td><a href="http://wg21.link/cwg1099">1099</a></td>
+    <td><a href="https://wg21.link/cwg1099">1099</a></td>
     <td>C++11</td>
     <td>Infinite recursion in <TT>constexpr</TT> functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1100">
-    <td><a href="http://wg21.link/cwg1100">1100</a></td>
+    <td><a href="https://wg21.link/cwg1100">1100</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> conversion functions and non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1101">
-    <td><a href="http://wg21.link/cwg1101">1101</a></td>
+    <td><a href="https://wg21.link/cwg1101">1101</a></td>
     <td>C++11</td>
     <td>Non-integral initialized static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1102">
-    <td><a href="http://wg21.link/cwg1102">1102</a></td>
+    <td><a href="https://wg21.link/cwg1102">1102</a></td>
     <td>C++11</td>
     <td>Better example of undefined behavior</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1103">
-    <td><a href="http://wg21.link/cwg1103">1103</a></td>
+    <td><a href="https://wg21.link/cwg1103">1103</a></td>
     <td>C++11</td>
     <td>Reversion of phase 1 and 2 transformations in raw string literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1104">
-    <td><a href="http://wg21.link/cwg1104">1104</a></td>
+    <td><a href="https://wg21.link/cwg1104">1104</a></td>
     <td>C++11</td>
     <td>Global-scope template arguments vs the <TT>&lt;:</TT> digraph</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1105">
-    <td><a href="http://wg21.link/cwg1105">1105</a></td>
+    <td><a href="https://wg21.link/cwg1105">1105</a></td>
     <td>C++11</td>
     <td>Issues relating to TR 10176:2003</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1106">
-    <td><a href="http://wg21.link/cwg1106">1106</a></td>
+    <td><a href="https://wg21.link/cwg1106">1106</a></td>
     <td>C++11</td>
     <td>Need more detail in <TT>nullptr</TT> keyword description</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1107">
-    <td><a href="http://wg21.link/cwg1107">1107</a></td>
+    <td><a href="https://wg21.link/cwg1107">1107</a></td>
     <td>C++11</td>
     <td>Overload resolution for user-defined integer literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1108">
-    <td><a href="http://wg21.link/cwg1108">1108</a></td>
+    <td><a href="https://wg21.link/cwg1108">1108</a></td>
     <td>NAD</td>
     <td>User-defined literals have not been implemented</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1109">
-    <td><a href="http://wg21.link/cwg1109">1109</a></td>
+    <td><a href="https://wg21.link/cwg1109">1109</a></td>
     <td>C++11</td>
     <td>When is &#8220;use&#8221; a reference to the ODR meaning?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1110">
-    <td><a href="http://wg21.link/cwg1110">1110</a></td>
+    <td><a href="https://wg21.link/cwg1110">1110</a></td>
     <td>NAD</td>
     <td>Incomplete return type should be allowed in <TT>decltype</TT> operand</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1111">
-    <td><a href="http://wg21.link/cwg1111">1111</a></td>
+    <td><a href="https://wg21.link/cwg1111">1111</a></td>
     <td>C++11</td>
     <td>Remove dual-scope lookup of member template names</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1112">
-    <td><a href="http://wg21.link/cwg1112">1112</a></td>
+    <td><a href="https://wg21.link/cwg1112">1112</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> variables should have internal linkage like <TT>const</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1113">
-    <td><a href="http://wg21.link/cwg1113">1113</a></td>
+    <td><a href="https://wg21.link/cwg1113">1113</a></td>
     <td>C++11</td>
     <td>Linkage of namespace member of unnamed namespace</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="1114">
-    <td><a href="http://wg21.link/cwg1114">1114</a></td>
+    <td><a href="https://wg21.link/cwg1114">1114</a></td>
     <td>C++11</td>
     <td>Incorrect use of placement <TT>new</TT> in example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1115">
-    <td><a href="http://wg21.link/cwg1115">1115</a></td>
+    <td><a href="https://wg21.link/cwg1115">1115</a></td>
     <td>C++11</td>
     <td>C-compatible alignment specification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1116">
-    <td><a href="http://wg21.link/cwg1116">1116</a></td>
+    <td><a href="https://wg21.link/cwg1116">1116</a></td>
     <td>CD4</td>
     <td>Aliasing of union members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1117">
-    <td><a href="http://wg21.link/cwg1117">1117</a></td>
+    <td><a href="https://wg21.link/cwg1117">1117</a></td>
     <td>C++11</td>
     <td>Incorrect note about xvalue member access expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1118">
-    <td><a href="http://wg21.link/cwg1118">1118</a></td>
+    <td><a href="https://wg21.link/cwg1118">1118</a></td>
     <td>NAD</td>
     <td>Implicit lambda capture via explicit copy constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1119">
-    <td><a href="http://wg21.link/cwg1119">1119</a></td>
+    <td><a href="https://wg21.link/cwg1119">1119</a></td>
     <td>C++11</td>
     <td>Missing case in description of member access ambiguity</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1120">
-    <td><a href="http://wg21.link/cwg1120">1120</a></td>
+    <td><a href="https://wg21.link/cwg1120">1120</a></td>
     <td>C++11</td>
     <td><TT>reinterpret_cast</TT> and <TT>void*</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1121">
-    <td><a href="http://wg21.link/cwg1121">1121</a></td>
+    <td><a href="https://wg21.link/cwg1121">1121</a></td>
     <td>C++11</td>
     <td>Unnecessary ambiguity error in formation of pointer to member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1122">
-    <td><a href="http://wg21.link/cwg1122">1122</a></td>
+    <td><a href="https://wg21.link/cwg1122">1122</a></td>
     <td>C++11</td>
     <td>Circular definition of <TT>std::size_t</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1123">
-    <td><a href="http://wg21.link/cwg1123">1123</a></td>
+    <td><a href="https://wg21.link/cwg1123">1123</a></td>
     <td>C++11</td>
     <td>Destructors should be <TT>noexcept</TT> by default</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1124">
-    <td><a href="http://wg21.link/cwg1124">1124</a></td>
+    <td><a href="https://wg21.link/cwg1124">1124</a></td>
     <td>NAD</td>
     <td>Error in description of value category of pointer-to-member expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1125">
-    <td><a href="http://wg21.link/cwg1125">1125</a></td>
+    <td><a href="https://wg21.link/cwg1125">1125</a></td>
     <td>C++11</td>
     <td>Unclear definition of &#8220;potential constant expression&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1126">
-    <td><a href="http://wg21.link/cwg1126">1126</a></td>
+    <td><a href="https://wg21.link/cwg1126">1126</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> functions in <TT>const</TT> initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1127">
-    <td><a href="http://wg21.link/cwg1127">1127</a></td>
+    <td><a href="https://wg21.link/cwg1127">1127</a></td>
     <td>C++11</td>
     <td>Overload resolution in <TT>constexpr</TT> functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1128">
-    <td><a href="http://wg21.link/cwg1128">1128</a></td>
+    <td><a href="https://wg21.link/cwg1128">1128</a></td>
     <td>C++11</td>
     <td><I>attribute-specifier</I>s in <I>decl-specifier-seq</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1129">
-    <td><a href="http://wg21.link/cwg1129">1129</a></td>
+    <td><a href="https://wg21.link/cwg1129">1129</a></td>
     <td>C++11</td>
     <td>Default <TT>nothrow</TT> for <TT>constexpr</TT> functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1130">
-    <td><a href="http://wg21.link/cwg1130">1130</a></td>
+    <td><a href="https://wg21.link/cwg1130">1130</a></td>
     <td>C++11</td>
     <td>Function parameter type adjustments and <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1131">
-    <td><a href="http://wg21.link/cwg1131">1131</a></td>
+    <td><a href="https://wg21.link/cwg1131">1131</a></td>
     <td>C++11</td>
     <td>Template aliases in <I>elaborated-type-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1132">
-    <td><a href="http://wg21.link/cwg1132">1132</a></td>
+    <td><a href="https://wg21.link/cwg1132">1132</a></td>
     <td>NAD</td>
     <td>Keyword vs attribute for <TT>noreturn</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1133">
-    <td><a href="http://wg21.link/cwg1133">1133</a></td>
+    <td><a href="https://wg21.link/cwg1133">1133</a></td>
     <td>C++11</td>
     <td>Keywords vs attributes for control of hiding and overriding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1134">
-    <td><a href="http://wg21.link/cwg1134">1134</a></td>
+    <td><a href="https://wg21.link/cwg1134">1134</a></td>
     <td>C++11</td>
     <td>When is an explicitly-defaulted function defined?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1135">
-    <td><a href="http://wg21.link/cwg1135">1135</a></td>
+    <td><a href="https://wg21.link/cwg1135">1135</a></td>
     <td>C++11</td>
     <td>Explicitly-defaulted non-public special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1136">
-    <td><a href="http://wg21.link/cwg1136">1136</a></td>
+    <td><a href="https://wg21.link/cwg1136">1136</a></td>
     <td>C++11</td>
     <td>Explicitly-defaulted explicit constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1137">
-    <td><a href="http://wg21.link/cwg1137">1137</a></td>
+    <td><a href="https://wg21.link/cwg1137">1137</a></td>
     <td>C++11</td>
     <td>Explicitly-defaulted virtual special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1138">
-    <td><a href="http://wg21.link/cwg1138">1138</a></td>
+    <td><a href="https://wg21.link/cwg1138">1138</a></td>
     <td>C++11</td>
     <td>Rvalue-ness check for rvalue reference binding is wrong</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1139">
-    <td><a href="http://wg21.link/cwg1139">1139</a></td>
+    <td><a href="https://wg21.link/cwg1139">1139</a></td>
     <td>C++11</td>
     <td>Rvalue reference binding to scalar xvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1140">
-    <td><a href="http://wg21.link/cwg1140">1140</a></td>
+    <td><a href="https://wg21.link/cwg1140">1140</a></td>
     <td>C++11</td>
     <td>Incorrect redefinition of POD class</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1141">
-    <td><a href="http://wg21.link/cwg1141">1141</a></td>
+    <td><a href="https://wg21.link/cwg1141">1141</a></td>
     <td>NAD</td>
     <td>Non-static data member initializers have not been implemented</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1142">
-    <td><a href="http://wg21.link/cwg1142">1142</a></td>
+    <td><a href="https://wg21.link/cwg1142">1142</a></td>
     <td>C++11</td>
     <td><TT>friend</TT> declaration of member function of containing class</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1143">
-    <td><a href="http://wg21.link/cwg1143">1143</a></td>
+    <td><a href="https://wg21.link/cwg1143">1143</a></td>
     <td>NAD</td>
     <td>Move semantics for <TT>*this</TT> have not been implemented</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1144">
-    <td><a href="http://wg21.link/cwg1144">1144</a></td>
+    <td><a href="https://wg21.link/cwg1144">1144</a></td>
     <td>C++11</td>
     <td>Remove access declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1145">
-    <td><a href="http://wg21.link/cwg1145">1145</a></td>
+    <td><a href="https://wg21.link/cwg1145">1145</a></td>
     <td>C++11</td>
     <td>Defaulting and triviality</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1146">
-    <td><a href="http://wg21.link/cwg1146">1146</a></td>
+    <td><a href="https://wg21.link/cwg1146">1146</a></td>
     <td>C++11</td>
     <td><I>exception-specification</I>s of defaulted functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1147">
-    <td><a href="http://wg21.link/cwg1147">1147</a></td>
+    <td><a href="https://wg21.link/cwg1147">1147</a></td>
     <td>C++11</td>
     <td>Destructors should be default <TT>nothrow</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1148">
-    <td><a href="http://wg21.link/cwg1148">1148</a></td>
+    <td><a href="https://wg21.link/cwg1148">1148</a></td>
     <td>C++11</td>
     <td>Copy elision and move construction of function parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1149">
-    <td><a href="http://wg21.link/cwg1149">1149</a></td>
+    <td><a href="https://wg21.link/cwg1149">1149</a></td>
     <td>C++11</td>
     <td>Trivial non-public copy operators in subobjects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1150">
-    <td><a href="http://wg21.link/cwg1150">1150</a></td>
+    <td><a href="https://wg21.link/cwg1150">1150</a></td>
     <td>NAD</td>
     <td>Inheriting constructors have not been implemented</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1151">
-    <td><a href="http://wg21.link/cwg1151">1151</a></td>
+    <td><a href="https://wg21.link/cwg1151">1151</a></td>
     <td>C++11</td>
     <td>Overload resolution with initializer-list and non-list constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1152">
-    <td><a href="http://wg21.link/cwg1152">1152</a></td>
+    <td><a href="https://wg21.link/cwg1152">1152</a></td>
     <td>C++11</td>
     <td>Rules for determining existence of implicit conversion sequence</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1153">
-    <td><a href="http://wg21.link/cwg1153">1153</a></td>
+    <td><a href="https://wg21.link/cwg1153">1153</a></td>
     <td>C++11</td>
     <td>Type matching in address of overloaded function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1154">
-    <td><a href="http://wg21.link/cwg1154">1154</a></td>
+    <td><a href="https://wg21.link/cwg1154">1154</a></td>
     <td>C++11</td>
     <td>Address of <TT>thread_local</TT> variable as non-type template argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1155">
-    <td><a href="http://wg21.link/cwg1155">1155</a></td>
+    <td><a href="https://wg21.link/cwg1155">1155</a></td>
     <td>C++11</td>
     <td>Internal-linkage non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1156">
-    <td><a href="http://wg21.link/cwg1156">1156</a></td>
+    <td><a href="https://wg21.link/cwg1156">1156</a></td>
     <td>C++11</td>
     <td>Partial ordering in a non-call context</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1157">
-    <td><a href="http://wg21.link/cwg1157">1157</a></td>
+    <td><a href="https://wg21.link/cwg1157">1157</a></td>
     <td>open</td>
     <td>Partial ordering of function templates is still underspecified</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1158">
-    <td><a href="http://wg21.link/cwg1158">1158</a></td>
+    <td><a href="https://wg21.link/cwg1158">1158</a></td>
     <td>C++11</td>
     <td>Recursive instantiation via alias template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1159">
-    <td><a href="http://wg21.link/cwg1159">1159</a></td>
+    <td><a href="https://wg21.link/cwg1159">1159</a></td>
     <td>C++11</td>
     <td>Class and enumeration definitions in template aliases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1160">
-    <td><a href="http://wg21.link/cwg1160">1160</a></td>
+    <td><a href="https://wg21.link/cwg1160">1160</a></td>
     <td>C++11</td>
     <td>Definitions of template members and the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1161">
-    <td><a href="http://wg21.link/cwg1161">1161</a></td>
+    <td><a href="https://wg21.link/cwg1161">1161</a></td>
     <td>C++11</td>
     <td>Dependent <I>nested-name-specifier</I> in a pointer-to-member declarator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1162">
-    <td><a href="http://wg21.link/cwg1162">1162</a></td>
+    <td><a href="https://wg21.link/cwg1162">1162</a></td>
     <td>NAD</td>
     <td>Dependent <I>elaborated-type-specifier</I>s in non-deduced contexts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1163">
-    <td><a href="http://wg21.link/cwg1163">1163</a></td>
+    <td><a href="https://wg21.link/cwg1163">1163</a></td>
     <td>NAD</td>
     <td><TT>extern template</TT> prevents inlining functions not marked <TT>inline</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1164">
-    <td><a href="http://wg21.link/cwg1164">1164</a></td>
+    <td><a href="https://wg21.link/cwg1164">1164</a></td>
     <td>C++11</td>
     <td>Partial ordering of <TT>f(T&amp;)</TT> and <TT>f(T&amp;&amp;)</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1165">
-    <td><a href="http://wg21.link/cwg1165">1165</a></td>
+    <td><a href="https://wg21.link/cwg1165">1165</a></td>
     <td>C++11</td>
     <td>Exceptions when destroying array elements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1166">
-    <td><a href="http://wg21.link/cwg1166">1166</a></td>
+    <td><a href="https://wg21.link/cwg1166">1166</a></td>
     <td>C++11</td>
     <td><I>exception-declaration</I>s that do not declare objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1167">
-    <td><a href="http://wg21.link/cwg1167">1167</a></td>
+    <td><a href="https://wg21.link/cwg1167">1167</a></td>
     <td>C++11</td>
     <td><I>function-try-block</I>s for destructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1168">
-    <td><a href="http://wg21.link/cwg1168">1168</a></td>
+    <td><a href="https://wg21.link/cwg1168">1168</a></td>
     <td>C++11</td>
     <td>Additional reasons to call <TT>std::terminate</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1169">
-    <td><a href="http://wg21.link/cwg1169">1169</a></td>
+    <td><a href="https://wg21.link/cwg1169">1169</a></td>
     <td>C++11</td>
     <td>Missing feature macro for strict pointer safety</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1170">
-    <td><a href="http://wg21.link/cwg1170">1170</a></td>
+    <td><a href="https://wg21.link/cwg1170">1170</a></td>
     <td>C++11</td>
     <td>Access checking during template argument deduction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1171">
-    <td><a href="http://wg21.link/cwg1171">1171</a></td>
+    <td><a href="https://wg21.link/cwg1171">1171</a></td>
     <td>C++11</td>
     <td>Partial stack unwinding with <TT>noexcept</TT> violation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1172">
-    <td><a href="http://wg21.link/cwg1172">1172</a></td>
+    <td><a href="https://wg21.link/cwg1172">1172</a></td>
     <td>drafting</td>
     <td>&#8220;instantiation-dependent&#8221; constructs</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1173">
-    <td><a href="http://wg21.link/cwg1173">1173</a></td>
+    <td><a href="https://wg21.link/cwg1173">1173</a></td>
     <td>C++11</td>
     <td>Unclear specification of effects of signal handling</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1174">
-    <td><a href="http://wg21.link/cwg1174">1174</a></td>
+    <td><a href="https://wg21.link/cwg1174">1174</a></td>
     <td>C++11</td>
     <td>When is a pure virtual function &#8220;used?&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1175">
-    <td><a href="http://wg21.link/cwg1175">1175</a></td>
+    <td><a href="https://wg21.link/cwg1175">1175</a></td>
     <td>C++11</td>
     <td>Disambiguating user-defined literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1176">
-    <td><a href="http://wg21.link/cwg1176">1176</a></td>
+    <td><a href="https://wg21.link/cwg1176">1176</a></td>
     <td>C++11</td>
     <td>Definition of release sequence</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1177">
-    <td><a href="http://wg21.link/cwg1177">1177</a></td>
+    <td><a href="https://wg21.link/cwg1177">1177</a></td>
     <td>C++11</td>
     <td>Intra-thread dependency-ordered-before</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1178">
-    <td><a href="http://wg21.link/cwg1178">1178</a></td>
+    <td><a href="https://wg21.link/cwg1178">1178</a></td>
     <td>C++11</td>
     <td>Deduction failure matching placement new</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1179">
-    <td><a href="http://wg21.link/cwg1179">1179</a></td>
+    <td><a href="https://wg21.link/cwg1179">1179</a></td>
     <td>NAD</td>
     <td>Cv-qualification of non-type template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1180">
-    <td><a href="http://wg21.link/cwg1180">1180</a></td>
+    <td><a href="https://wg21.link/cwg1180">1180</a></td>
     <td>C++11</td>
     <td>Over-aligned class types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1181">
-    <td><a href="http://wg21.link/cwg1181">1181</a></td>
+    <td><a href="https://wg21.link/cwg1181">1181</a></td>
     <td>C++11</td>
     <td>What is a &#8220;built-in type?&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1182">
-    <td><a href="http://wg21.link/cwg1182">1182</a></td>
+    <td><a href="https://wg21.link/cwg1182">1182</a></td>
     <td>C++11</td>
     <td>Incorrect description of pack expansion syntax</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1183">
-    <td><a href="http://wg21.link/cwg1183">1183</a></td>
+    <td><a href="https://wg21.link/cwg1183">1183</a></td>
     <td>C++11</td>
     <td>Expansion of parameter packs in declarators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1184">
-    <td><a href="http://wg21.link/cwg1184">1184</a></td>
+    <td><a href="https://wg21.link/cwg1184">1184</a></td>
     <td>C++11</td>
     <td>Argument conversions to nondeduced parameter types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1185">
-    <td><a href="http://wg21.link/cwg1185">1185</a></td>
+    <td><a href="https://wg21.link/cwg1185">1185</a></td>
     <td>C++11</td>
     <td>Misleading description of language linkage and member function types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1186">
-    <td><a href="http://wg21.link/cwg1186">1186</a></td>
+    <td><a href="https://wg21.link/cwg1186">1186</a></td>
     <td>C++11</td>
     <td>Non-dependent <TT>constexpr</TT> violations in function templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1187">
-    <td><a href="http://wg21.link/cwg1187">1187</a></td>
+    <td><a href="https://wg21.link/cwg1187">1187</a></td>
     <td>C++11</td>
     <td>Problems in initialization example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1188">
-    <td><a href="http://wg21.link/cwg1188">1188</a></td>
+    <td><a href="https://wg21.link/cwg1188">1188</a></td>
     <td>C++11</td>
     <td>Type punning in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1189">
-    <td><a href="http://wg21.link/cwg1189">1189</a></td>
+    <td><a href="https://wg21.link/cwg1189">1189</a></td>
     <td>C++11</td>
     <td>Address of distinct base class subobjects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1190">
-    <td><a href="http://wg21.link/cwg1190">1190</a></td>
+    <td><a href="https://wg21.link/cwg1190">1190</a></td>
     <td>C++11</td>
     <td>Operations on non-safely-derived pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1191">
-    <td><a href="http://wg21.link/cwg1191">1191</a></td>
+    <td><a href="https://wg21.link/cwg1191">1191</a></td>
     <td>C++11</td>
     <td>Deleted subobject destructors and implicitly-defined constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1192">
-    <td><a href="http://wg21.link/cwg1192">1192</a></td>
+    <td><a href="https://wg21.link/cwg1192">1192</a></td>
     <td>C++11</td>
     <td>Inadvertent change to ODR and templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1193">
-    <td><a href="http://wg21.link/cwg1193">1193</a></td>
+    <td><a href="https://wg21.link/cwg1193">1193</a></td>
     <td>C++11</td>
     <td>Use of address-constant pointers in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1194">
-    <td><a href="http://wg21.link/cwg1194">1194</a></td>
+    <td><a href="https://wg21.link/cwg1194">1194</a></td>
     <td>C++11</td>
     <td>Constexpr references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1195">
-    <td><a href="http://wg21.link/cwg1195">1195</a></td>
+    <td><a href="https://wg21.link/cwg1195">1195</a></td>
     <td>C++11</td>
     <td>References to non-literal types in constexpr functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1196">
-    <td><a href="http://wg21.link/cwg1196">1196</a></td>
+    <td><a href="https://wg21.link/cwg1196">1196</a></td>
     <td>C++11</td>
     <td>Definition required for explicit instantiation after explicit specialization?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1197">
-    <td><a href="http://wg21.link/cwg1197">1197</a></td>
+    <td><a href="https://wg21.link/cwg1197">1197</a></td>
     <td>C++11</td>
     <td>Constexpr arrays</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1198">
-    <td><a href="http://wg21.link/cwg1198">1198</a></td>
+    <td><a href="https://wg21.link/cwg1198">1198</a></td>
     <td>C++11</td>
     <td>Literal types and copy constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1199">
-    <td><a href="http://wg21.link/cwg1199">1199</a></td>
+    <td><a href="https://wg21.link/cwg1199">1199</a></td>
     <td>C++11</td>
     <td>Deleted constexpr functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1200">
-    <td><a href="http://wg21.link/cwg1200">1200</a></td>
+    <td><a href="https://wg21.link/cwg1200">1200</a></td>
     <td>open</td>
     <td>Lookup rules for template parameters</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1201">
-    <td><a href="http://wg21.link/cwg1201">1201</a></td>
+    <td><a href="https://wg21.link/cwg1201">1201</a></td>
     <td>C++11</td>
     <td>Are deleted and defaulted functions definitions?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1202">
-    <td><a href="http://wg21.link/cwg1202">1202</a></td>
+    <td><a href="https://wg21.link/cwg1202">1202</a></td>
     <td>C++11</td>
     <td>Calling virtual functions during destruction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1203">
-    <td><a href="http://wg21.link/cwg1203">1203</a></td>
+    <td><a href="https://wg21.link/cwg1203">1203</a></td>
     <td>dup</td>
     <td>Misleading note regarding initialized static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1204">
-    <td><a href="http://wg21.link/cwg1204">1204</a></td>
+    <td><a href="https://wg21.link/cwg1204">1204</a></td>
     <td>C++11</td>
     <td>Specifiers in a <I>for-range-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1205">
-    <td><a href="http://wg21.link/cwg1205">1205</a></td>
+    <td><a href="https://wg21.link/cwg1205">1205</a></td>
     <td>dup</td>
     <td>Lvalue reference binding and function viability</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1206">
-    <td><a href="http://wg21.link/cwg1206">1206</a></td>
+    <td><a href="https://wg21.link/cwg1206">1206</a></td>
     <td>C++11</td>
     <td>Defining opaque enumeration members of class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1207">
-    <td><a href="http://wg21.link/cwg1207">1207</a></td>
+    <td><a href="https://wg21.link/cwg1207">1207</a></td>
     <td>C++11</td>
     <td>Type of class member in <I>trailing-return-type</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1208">
-    <td><a href="http://wg21.link/cwg1208">1208</a></td>
+    <td><a href="https://wg21.link/cwg1208">1208</a></td>
     <td>C++11</td>
     <td>Explicit <TT>noexcept</TT> in defaulted definition</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1209">
-    <td><a href="http://wg21.link/cwg1209">1209</a></td>
+    <td><a href="https://wg21.link/cwg1209">1209</a></td>
     <td>open</td>
     <td>Is a potentially-evaluated expression in a template definition a &#8220;use?&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1210">
-    <td><a href="http://wg21.link/cwg1210">1210</a></td>
+    <td><a href="https://wg21.link/cwg1210">1210</a></td>
     <td>C++11</td>
     <td>Injection of <I>elaborated-type-specifier</I> in enumeration scope</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1211">
-    <td><a href="http://wg21.link/cwg1211">1211</a></td>
+    <td><a href="https://wg21.link/cwg1211">1211</a></td>
     <td>drafting</td>
     <td>Misaligned lvalues</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1212">
-    <td><a href="http://wg21.link/cwg1212">1212</a></td>
+    <td><a href="https://wg21.link/cwg1212">1212</a></td>
     <td>C++11</td>
     <td>Non-function-call xvalues and <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1213">
-    <td><a href="http://wg21.link/cwg1213">1213</a></td>
+    <td><a href="https://wg21.link/cwg1213">1213</a></td>
     <td>CD3</td>
     <td>Array subscripting and xvalues</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="1214">
-    <td><a href="http://wg21.link/cwg1214">1214</a></td>
+    <td><a href="https://wg21.link/cwg1214">1214</a></td>
     <td>C++11</td>
     <td>Kinds of initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1215">
-    <td><a href="http://wg21.link/cwg1215">1215</a></td>
+    <td><a href="https://wg21.link/cwg1215">1215</a></td>
     <td>C++11</td>
     <td>Definition of POD struct</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1216">
-    <td><a href="http://wg21.link/cwg1216">1216</a></td>
+    <td><a href="https://wg21.link/cwg1216">1216</a></td>
     <td>C++11</td>
     <td>Exceptions &#8220;allowed&#8221; by a <I>noexcept-specification</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1217">
-    <td><a href="http://wg21.link/cwg1217">1217</a></td>
+    <td><a href="https://wg21.link/cwg1217">1217</a></td>
     <td>NAD</td>
     <td>Are deleted functions implicitly <TT>noexcept</TT>?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1218">
-    <td><a href="http://wg21.link/cwg1218">1218</a></td>
+    <td><a href="https://wg21.link/cwg1218">1218</a></td>
     <td>C++11</td>
     <td>What is the &#8220;currently-handled exception&#8221; in a multi-threaded program?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1219">
-    <td><a href="http://wg21.link/cwg1219">1219</a></td>
+    <td><a href="https://wg21.link/cwg1219">1219</a></td>
     <td>C++11</td>
     <td>Non-static data member initializers in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1220">
-    <td><a href="http://wg21.link/cwg1220">1220</a></td>
+    <td><a href="https://wg21.link/cwg1220">1220</a></td>
     <td>C++11</td>
     <td>Looking up <I>conversion-type-id</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1221">
-    <td><a href="http://wg21.link/cwg1221">1221</a></td>
+    <td><a href="https://wg21.link/cwg1221">1221</a></td>
     <td>open</td>
     <td>Partial ordering and reference collapsing</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1222">
-    <td><a href="http://wg21.link/cwg1222">1222</a></td>
+    <td><a href="https://wg21.link/cwg1222">1222</a></td>
     <td>NAD</td>
     <td>Unnecessary restriction on <TT>auto</TT> array types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1223">
-    <td><a href="http://wg21.link/cwg1223">1223</a></td>
+    <td><a href="https://wg21.link/cwg1223">1223</a></td>
     <td>drafting</td>
     <td>Syntactic disambiguation and <I>trailing-return-type</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1224">
-    <td><a href="http://wg21.link/cwg1224">1224</a></td>
+    <td><a href="https://wg21.link/cwg1224">1224</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> defaulted copy constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1225">
-    <td><a href="http://wg21.link/cwg1225">1225</a></td>
+    <td><a href="https://wg21.link/cwg1225">1225</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> constructors and virtual bases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1226">
-    <td><a href="http://wg21.link/cwg1226">1226</a></td>
+    <td><a href="https://wg21.link/cwg1226">1226</a></td>
     <td>CD3</td>
     <td>Converting a <I>braced-init-list</I> default argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1227">
-    <td><a href="http://wg21.link/cwg1227">1227</a></td>
+    <td><a href="https://wg21.link/cwg1227">1227</a></td>
     <td>CD3</td>
     <td>Mixing immediate and non-immediate contexts in deduction failure</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1228">
-    <td><a href="http://wg21.link/cwg1228">1228</a></td>
+    <td><a href="https://wg21.link/cwg1228">1228</a></td>
     <td>NAD</td>
     <td>Copy-list-initialization and <TT>explicit</TT> constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1229">
-    <td><a href="http://wg21.link/cwg1229">1229</a></td>
+    <td><a href="https://wg21.link/cwg1229">1229</a></td>
     <td>C++11</td>
     <td>Overload resolution with empty <I>braced-init-list</I> argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1230">
-    <td><a href="http://wg21.link/cwg1230">1230</a></td>
+    <td><a href="https://wg21.link/cwg1230">1230</a></td>
     <td>open</td>
     <td>Confusing description of ambiguity of destructor name</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1231">
-    <td><a href="http://wg21.link/cwg1231">1231</a></td>
+    <td><a href="https://wg21.link/cwg1231">1231</a></td>
     <td>C++11</td>
     <td>Variadic templates requiring an empty pack expansion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1232">
-    <td><a href="http://wg21.link/cwg1232">1232</a></td>
+    <td><a href="https://wg21.link/cwg1232">1232</a></td>
     <td>C++11</td>
     <td>Creation of array temporaries using a <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1233">
-    <td><a href="http://wg21.link/cwg1233">1233</a></td>
+    <td><a href="https://wg21.link/cwg1233">1233</a></td>
     <td>C++11</td>
     <td>Pack expansions and dependent calls</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1234">
-    <td><a href="http://wg21.link/cwg1234">1234</a></td>
+    <td><a href="https://wg21.link/cwg1234">1234</a></td>
     <td>C++11</td>
     <td><I>abstract-declarator</I> does not permit <TT>...</TT> after <I>ptr-operator</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1235">
-    <td><a href="http://wg21.link/cwg1235">1235</a></td>
+    <td><a href="https://wg21.link/cwg1235">1235</a></td>
     <td>C++11</td>
     <td>&#8220;Unused&#8221; ellipsis and default arguments in partial ordering</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1236">
-    <td><a href="http://wg21.link/cwg1236">1236</a></td>
+    <td><a href="https://wg21.link/cwg1236">1236</a></td>
     <td>C++11</td>
     <td>Inconsistently-interrelated examples</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1237">
-    <td><a href="http://wg21.link/cwg1237">1237</a></td>
+    <td><a href="https://wg21.link/cwg1237">1237</a></td>
     <td>C++11</td>
     <td>Deprecated implicit copy assignment in example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1238">
-    <td><a href="http://wg21.link/cwg1238">1238</a></td>
+    <td><a href="https://wg21.link/cwg1238">1238</a></td>
     <td>C++11</td>
     <td>Overloading ambiguity binding reference to function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1239">
-    <td><a href="http://wg21.link/cwg1239">1239</a></td>
+    <td><a href="https://wg21.link/cwg1239">1239</a></td>
     <td>C++11</td>
     <td>Hexadecimal floating-point literals vs user-defined literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1240">
-    <td><a href="http://wg21.link/cwg1240">1240</a></td>
+    <td><a href="https://wg21.link/cwg1240">1240</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> defaulted constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1241">
-    <td><a href="http://wg21.link/cwg1241">1241</a></td>
+    <td><a href="https://wg21.link/cwg1241">1241</a></td>
     <td>C++11</td>
     <td>Which members does a destructor destroy?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1242">
-    <td><a href="http://wg21.link/cwg1242">1242</a></td>
+    <td><a href="https://wg21.link/cwg1242">1242</a></td>
     <td>C++11</td>
     <td>Initializing variant class members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1243">
-    <td><a href="http://wg21.link/cwg1243">1243</a></td>
+    <td><a href="https://wg21.link/cwg1243">1243</a></td>
     <td>C++11</td>
     <td>Misleading footnote regarding multiple-declarator declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1244">
-    <td><a href="http://wg21.link/cwg1244">1244</a></td>
+    <td><a href="https://wg21.link/cwg1244">1244</a></td>
     <td>C++11</td>
     <td>Equivalence of alias templates and class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1245">
-    <td><a href="http://wg21.link/cwg1245">1245</a></td>
+    <td><a href="https://wg21.link/cwg1245">1245</a></td>
     <td>C++11</td>
     <td>Matching declarations involving <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1246">
-    <td><a href="http://wg21.link/cwg1246">1246</a></td>
+    <td><a href="https://wg21.link/cwg1246">1246</a></td>
     <td>C++11</td>
     <td>Non-deduced non-final parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1247">
-    <td><a href="http://wg21.link/cwg1247">1247</a></td>
+    <td><a href="https://wg21.link/cwg1247">1247</a></td>
     <td>CD4</td>
     <td>Restriction on alias name appearing in <I>type-id</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1248">
-    <td><a href="http://wg21.link/cwg1248">1248</a></td>
+    <td><a href="https://wg21.link/cwg1248">1248</a></td>
     <td>open</td>
     <td>Updating Annex C to C99</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1249">
-    <td><a href="http://wg21.link/cwg1249">1249</a></td>
+    <td><a href="https://wg21.link/cwg1249">1249</a></td>
     <td>drafting</td>
     <td>Cv-qualification of nested lambda capture</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1250">
-    <td><a href="http://wg21.link/cwg1250">1250</a></td>
+    <td><a href="https://wg21.link/cwg1250">1250</a></td>
     <td>CD3</td>
     <td>Cv-qualification of incomplete virtual function return types</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1251">
-    <td><a href="http://wg21.link/cwg1251">1251</a></td>
+    <td><a href="https://wg21.link/cwg1251">1251</a></td>
     <td>CD3</td>
     <td>C compatibility: casting to unqualified <TT>void*</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1252">
-    <td><a href="http://wg21.link/cwg1252">1252</a></td>
+    <td><a href="https://wg21.link/cwg1252">1252</a></td>
     <td>drafting</td>
     <td>Overloading member function templates based on dependent return type</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1253">
-    <td><a href="http://wg21.link/cwg1253">1253</a></td>
+    <td><a href="https://wg21.link/cwg1253">1253</a></td>
     <td>drafting</td>
     <td>Generic non-template members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1254">
-    <td><a href="http://wg21.link/cwg1254">1254</a></td>
+    <td><a href="https://wg21.link/cwg1254">1254</a></td>
     <td>NAD</td>
     <td>odr-use vs template arguments and constexpr functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1255">
-    <td><a href="http://wg21.link/cwg1255">1255</a></td>
+    <td><a href="https://wg21.link/cwg1255">1255</a></td>
     <td>drafting</td>
     <td>Definition problems with <TT>constexpr</TT> functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1256">
-    <td><a href="http://wg21.link/cwg1256">1256</a></td>
+    <td><a href="https://wg21.link/cwg1256">1256</a></td>
     <td>open</td>
     <td>Unevaluated operands are not necessarily constant expressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1257">
-    <td><a href="http://wg21.link/cwg1257">1257</a></td>
+    <td><a href="https://wg21.link/cwg1257">1257</a></td>
     <td>open</td>
     <td>Instantiation via non-dependent references in uninstantiated templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1258">
-    <td><a href="http://wg21.link/cwg1258">1258</a></td>
+    <td><a href="https://wg21.link/cwg1258">1258</a></td>
     <td>drafting</td>
     <td>&#8220;Instantiation context&#8221; differs from dependent lookup rules</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1259">
-    <td><a href="http://wg21.link/cwg1259">1259</a></td>
+    <td><a href="https://wg21.link/cwg1259">1259</a></td>
     <td>NAD</td>
     <td>Deleting a POD via a pointer to base</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1260">
-    <td><a href="http://wg21.link/cwg1260">1260</a></td>
+    <td><a href="https://wg21.link/cwg1260">1260</a></td>
     <td>CD3</td>
     <td>Incorrect use of term &#8220;overloaded&#8221; in description of odr-use</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1261">
-    <td><a href="http://wg21.link/cwg1261">1261</a></td>
+    <td><a href="https://wg21.link/cwg1261">1261</a></td>
     <td>CD3</td>
     <td>Explicit handling of cv-qualification with non-class prvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1262">
-    <td><a href="http://wg21.link/cwg1262">1262</a></td>
+    <td><a href="https://wg21.link/cwg1262">1262</a></td>
     <td>CD3</td>
     <td>Default template arguments and deduction failure</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1263">
-    <td><a href="http://wg21.link/cwg1263">1263</a></td>
+    <td><a href="https://wg21.link/cwg1263">1263</a></td>
     <td>NAD</td>
     <td>Mismatch between rvalue reference binding and overload resolution</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1264">
-    <td><a href="http://wg21.link/cwg1264">1264</a></td>
+    <td><a href="https://wg21.link/cwg1264">1264</a></td>
     <td>CD3</td>
     <td>Use of <TT>this</TT> in <TT>constexpr</TT> constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1265">
-    <td><a href="http://wg21.link/cwg1265">1265</a></td>
+    <td><a href="https://wg21.link/cwg1265">1265</a></td>
     <td>CD3</td>
     <td>Mixed use of the <TT>auto</TT> specifier</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr class="open" id="1266">
-    <td><a href="http://wg21.link/cwg1266">1266</a></td>
+    <td><a href="https://wg21.link/cwg1266">1266</a></td>
     <td>open</td>
     <td><I>user-defined-integer-literal</I> overflow</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1267">
-    <td><a href="http://wg21.link/cwg1267">1267</a></td>
+    <td><a href="https://wg21.link/cwg1267">1267</a></td>
     <td>CD3</td>
     <td>Rvalue reference types in <I>exception-specification</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1268">
-    <td><a href="http://wg21.link/cwg1268">1268</a></td>
+    <td><a href="https://wg21.link/cwg1268">1268</a></td>
     <td>CD3</td>
     <td><TT>reinterpret_cast</TT> of an xvalue operand</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1269">
-    <td><a href="http://wg21.link/cwg1269">1269</a></td>
+    <td><a href="https://wg21.link/cwg1269">1269</a></td>
     <td>CD3</td>
     <td><TT>dynamic_cast</TT> of an xvalue operand</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1270">
-    <td><a href="http://wg21.link/cwg1270">1270</a></td>
+    <td><a href="https://wg21.link/cwg1270">1270</a></td>
     <td>CD3</td>
     <td>Brace elision in array temporary initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1271">
-    <td><a href="http://wg21.link/cwg1271">1271</a></td>
+    <td><a href="https://wg21.link/cwg1271">1271</a></td>
     <td>DRWP</td>
     <td>Imprecise wording regarding dependent types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1272">
-    <td><a href="http://wg21.link/cwg1272">1272</a></td>
+    <td><a href="https://wg21.link/cwg1272">1272</a></td>
     <td>NAD</td>
     <td>Implicit definition of static data member of const literal type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1273">
-    <td><a href="http://wg21.link/cwg1273">1273</a></td>
+    <td><a href="https://wg21.link/cwg1273">1273</a></td>
     <td>NAD</td>
     <td>Accessibility and function signatures</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1274">
-    <td><a href="http://wg21.link/cwg1274">1274</a></td>
+    <td><a href="https://wg21.link/cwg1274">1274</a></td>
     <td>CD4</td>
     <td>Common nonterminal for <I>expression</I> and <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1275">
-    <td><a href="http://wg21.link/cwg1275">1275</a></td>
+    <td><a href="https://wg21.link/cwg1275">1275</a></td>
     <td>CD3</td>
     <td>Incorrect comment in example of template parameter pack restriction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1276">
-    <td><a href="http://wg21.link/cwg1276">1276</a></td>
+    <td><a href="https://wg21.link/cwg1276">1276</a></td>
     <td>NAD</td>
     <td>Reference to <TT>stdint.h</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1277">
-    <td><a href="http://wg21.link/cwg1277">1277</a></td>
+    <td><a href="https://wg21.link/cwg1277">1277</a></td>
     <td>NAD</td>
     <td>Lax definition of <TT>intmax_t</TT> and <TT>uintmax_t</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1278">
-    <td><a href="http://wg21.link/cwg1278">1278</a></td>
+    <td><a href="https://wg21.link/cwg1278">1278</a></td>
     <td>drafting</td>
     <td>Incorrect treatment of contrived object</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1279">
-    <td><a href="http://wg21.link/cwg1279">1279</a></td>
+    <td><a href="https://wg21.link/cwg1279">1279</a></td>
     <td>drafting</td>
     <td>Additional differences between C++ 2003 and C++ 2011</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1280">
-    <td><a href="http://wg21.link/cwg1280">1280</a></td>
+    <td><a href="https://wg21.link/cwg1280">1280</a></td>
     <td>NAD</td>
     <td>Object reallocation and reference members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1281">
-    <td><a href="http://wg21.link/cwg1281">1281</a></td>
+    <td><a href="https://wg21.link/cwg1281">1281</a></td>
     <td>NAD</td>
     <td>Virtual and dependent base classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1282">
-    <td><a href="http://wg21.link/cwg1282">1282</a></td>
+    <td><a href="https://wg21.link/cwg1282">1282</a></td>
     <td>CD3</td>
     <td>Underspecified destructor <I>exception-specification</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1283">
-    <td><a href="http://wg21.link/cwg1283">1283</a></td>
+    <td><a href="https://wg21.link/cwg1283">1283</a></td>
     <td>drafting</td>
     <td>Static data members of classes with typedef name for linkage purposes</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1284">
-    <td><a href="http://wg21.link/cwg1284">1284</a></td>
+    <td><a href="https://wg21.link/cwg1284">1284</a></td>
     <td>CD4</td>
     <td>Should the lifetime of an array be independent of that of its elements?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1285">
-    <td><a href="http://wg21.link/cwg1285">1285</a></td>
+    <td><a href="https://wg21.link/cwg1285">1285</a></td>
     <td>open</td>
     <td>Trivial destructors and object lifetime</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1286">
-    <td><a href="http://wg21.link/cwg1286">1286</a></td>
+    <td><a href="https://wg21.link/cwg1286">1286</a></td>
     <td>drafting</td>
     <td>Equivalence of alias templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1287">
-    <td><a href="http://wg21.link/cwg1287">1287</a></td>
+    <td><a href="https://wg21.link/cwg1287">1287</a></td>
     <td>C++14</td>
     <td>Direct initialization vs &#8220;implicit&#8221; conversion in reference binding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1288">
-    <td><a href="http://wg21.link/cwg1288">1288</a></td>
+    <td><a href="https://wg21.link/cwg1288">1288</a></td>
     <td>CD3</td>
     <td>Reference list initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1289">
-    <td><a href="http://wg21.link/cwg1289">1289</a></td>
+    <td><a href="https://wg21.link/cwg1289">1289</a></td>
     <td>NAD</td>
     <td>Can an alias template name the current instantiation?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1290">
-    <td><a href="http://wg21.link/cwg1290">1290</a></td>
+    <td><a href="https://wg21.link/cwg1290">1290</a></td>
     <td>CD3</td>
     <td>Lifetime of the underlying array of an <TT>initializer_list</TT> member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1291">
-    <td><a href="http://wg21.link/cwg1291">1291</a></td>
+    <td><a href="https://wg21.link/cwg1291">1291</a></td>
     <td>drafting</td>
     <td>Looking up a <I>conversion-type-id</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1292">
-    <td><a href="http://wg21.link/cwg1292">1292</a></td>
+    <td><a href="https://wg21.link/cwg1292">1292</a></td>
     <td>CD4</td>
     <td>Dependent calls with <I>braced-init-list</I>s containing a pack expansion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1293">
-    <td><a href="http://wg21.link/cwg1293">1293</a></td>
+    <td><a href="https://wg21.link/cwg1293">1293</a></td>
     <td>CD3</td>
     <td>String literals in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1294">
-    <td><a href="http://wg21.link/cwg1294">1294</a></td>
+    <td><a href="https://wg21.link/cwg1294">1294</a></td>
     <td>drafting</td>
     <td>Side effects in dynamic/static initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1295">
-    <td><a href="http://wg21.link/cwg1295">1295</a></td>
+    <td><a href="https://wg21.link/cwg1295">1295</a></td>
     <td>CD3</td>
     <td>Binding a reference to an rvalue bit-field</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="1296">
-    <td><a href="http://wg21.link/cwg1296">1296</a></td>
+    <td><a href="https://wg21.link/cwg1296">1296</a></td>
     <td>CD3</td>
     <td>Ill-formed template declarations (not just definitions)</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1297">
-    <td><a href="http://wg21.link/cwg1297">1297</a></td>
+    <td><a href="https://wg21.link/cwg1297">1297</a></td>
     <td>CD3</td>
     <td>Misplaced function <I>attribute-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1298">
-    <td><a href="http://wg21.link/cwg1298">1298</a></td>
+    <td><a href="https://wg21.link/cwg1298">1298</a></td>
     <td>CD3</td>
     <td>Incorrect example in overload resolution</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1299">
-    <td><a href="http://wg21.link/cwg1299">1299</a></td>
+    <td><a href="https://wg21.link/cwg1299">1299</a></td>
     <td>DRWP</td>
     <td>&#8220;Temporary objects&#8221; vs &#8220;temporary expressions&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1300">
-    <td><a href="http://wg21.link/cwg1300">1300</a></td>
+    <td><a href="https://wg21.link/cwg1300">1300</a></td>
     <td>dup</td>
     <td><TT>T()</TT> for array types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1301">
-    <td><a href="http://wg21.link/cwg1301">1301</a></td>
+    <td><a href="https://wg21.link/cwg1301">1301</a></td>
     <td>CD3</td>
     <td>Value initialization of union</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1302">
-    <td><a href="http://wg21.link/cwg1302">1302</a></td>
+    <td><a href="https://wg21.link/cwg1302">1302</a></td>
     <td>CD3</td>
     <td><TT>noexcept</TT> applied to expression of type <TT>void</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1303">
-    <td><a href="http://wg21.link/cwg1303">1303</a></td>
+    <td><a href="https://wg21.link/cwg1303">1303</a></td>
     <td>NAD</td>
     <td>C language linkage for template with internal linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1304">
-    <td><a href="http://wg21.link/cwg1304">1304</a></td>
+    <td><a href="https://wg21.link/cwg1304">1304</a></td>
     <td>drafting</td>
     <td>Omitted array bound with string initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1305">
-    <td><a href="http://wg21.link/cwg1305">1305</a></td>
+    <td><a href="https://wg21.link/cwg1305">1305</a></td>
     <td>CD3</td>
     <td><TT>alignof</TT> applied to array of unknown size</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1306">
-    <td><a href="http://wg21.link/cwg1306">1306</a></td>
+    <td><a href="https://wg21.link/cwg1306">1306</a></td>
     <td>CD3</td>
     <td>Modifying an object within a <TT>const</TT> member function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1307">
-    <td><a href="http://wg21.link/cwg1307">1307</a></td>
+    <td><a href="https://wg21.link/cwg1307">1307</a></td>
     <td>C++14</td>
     <td>Overload resolution based on size of array <I>initializer-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1308">
-    <td><a href="http://wg21.link/cwg1308">1308</a></td>
+    <td><a href="https://wg21.link/cwg1308">1308</a></td>
     <td>CD3</td>
     <td>Completeness of class type within an <I>exception-specification</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1309">
-    <td><a href="http://wg21.link/cwg1309">1309</a></td>
+    <td><a href="https://wg21.link/cwg1309">1309</a></td>
     <td>CD4</td>
     <td>Incorrect note regarding lookup of a member of the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1310">
-    <td><a href="http://wg21.link/cwg1310">1310</a></td>
+    <td><a href="https://wg21.link/cwg1310">1310</a></td>
     <td>CD3</td>
     <td>What is an &#8220;acceptable lookup result?&#8221;</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr id="1311">
-    <td><a href="http://wg21.link/cwg1311">1311</a></td>
+    <td><a href="https://wg21.link/cwg1311">1311</a></td>
     <td>CD3</td>
     <td>Volatile lvalues in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1312">
-    <td><a href="http://wg21.link/cwg1312">1312</a></td>
+    <td><a href="https://wg21.link/cwg1312">1312</a></td>
     <td>CD3</td>
     <td>Simulated <TT>reinterpret_cast</TT> in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1313">
-    <td><a href="http://wg21.link/cwg1313">1313</a></td>
+    <td><a href="https://wg21.link/cwg1313">1313</a></td>
     <td>CD3</td>
     <td>Undefined pointer arithmetic in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1314">
-    <td><a href="http://wg21.link/cwg1314">1314</a></td>
+    <td><a href="https://wg21.link/cwg1314">1314</a></td>
     <td>NAD</td>
     <td>Pointer arithmetic within standard-layout objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1315">
-    <td><a href="http://wg21.link/cwg1315">1315</a></td>
+    <td><a href="https://wg21.link/cwg1315">1315</a></td>
     <td>CD4</td>
     <td>Restrictions on non-type template arguments in partial specializations</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="1316">
-    <td><a href="http://wg21.link/cwg1316">1316</a></td>
+    <td><a href="https://wg21.link/cwg1316">1316</a></td>
     <td>NAD</td>
     <td><TT>constexpr</TT> function requirements and class scope</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1317">
-    <td><a href="http://wg21.link/cwg1317">1317</a></td>
+    <td><a href="https://wg21.link/cwg1317">1317</a></td>
     <td>NAD</td>
     <td>Unnamed scoped enumerations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1318">
-    <td><a href="http://wg21.link/cwg1318">1318</a></td>
+    <td><a href="https://wg21.link/cwg1318">1318</a></td>
     <td>CD3</td>
     <td>Syntactic ambiguities with <TT>final</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1319">
-    <td><a href="http://wg21.link/cwg1319">1319</a></td>
+    <td><a href="https://wg21.link/cwg1319">1319</a></td>
     <td>NAD</td>
     <td>Error in pack expansion example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1320">
-    <td><a href="http://wg21.link/cwg1320">1320</a></td>
+    <td><a href="https://wg21.link/cwg1320">1320</a></td>
     <td>CD3</td>
     <td>Converting scoped enumerations to <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1321">
-    <td><a href="http://wg21.link/cwg1321">1321</a></td>
+    <td><a href="https://wg21.link/cwg1321">1321</a></td>
     <td>CD3</td>
     <td>Equivalency of dependent calls</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1322">
-    <td><a href="http://wg21.link/cwg1322">1322</a></td>
+    <td><a href="https://wg21.link/cwg1322">1322</a></td>
     <td>drafting</td>
     <td>Function parameter type decay in templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1323">
-    <td><a href="http://wg21.link/cwg1323">1323</a></td>
+    <td><a href="https://wg21.link/cwg1323">1323</a></td>
     <td>NAD</td>
     <td>Nonexistent nonterminal in <I>alignment-specifier</I> grammar</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1324">
-    <td><a href="http://wg21.link/cwg1324">1324</a></td>
+    <td><a href="https://wg21.link/cwg1324">1324</a></td>
     <td>CD3</td>
     <td>Value initialization and defaulted constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1325">
-    <td><a href="http://wg21.link/cwg1325">1325</a></td>
+    <td><a href="https://wg21.link/cwg1325">1325</a></td>
     <td>NAD</td>
     <td>Omitted declarator in <TT>friend</TT> declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1326">
-    <td><a href="http://wg21.link/cwg1326">1326</a></td>
+    <td><a href="https://wg21.link/cwg1326">1326</a></td>
     <td>extension</td>
     <td>Deducing an array bound from an <I>initializer-list</I></td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1327">
-    <td><a href="http://wg21.link/cwg1327">1327</a></td>
+    <td><a href="https://wg21.link/cwg1327">1327</a></td>
     <td>CD3</td>
     <td><I>virt-specifier</I> in a defaulted definition</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1328">
-    <td><a href="http://wg21.link/cwg1328">1328</a></td>
+    <td><a href="https://wg21.link/cwg1328">1328</a></td>
     <td>CD3</td>
     <td>Conflict in reference binding vs overload resolution</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1329">
-    <td><a href="http://wg21.link/cwg1329">1329</a></td>
+    <td><a href="https://wg21.link/cwg1329">1329</a></td>
     <td>CD3</td>
     <td>Recursive deduction substitutions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1330">
-    <td><a href="http://wg21.link/cwg1330">1330</a></td>
+    <td><a href="https://wg21.link/cwg1330">1330</a></td>
     <td>CD3</td>
     <td>Delayed instantiation of <TT>noexcept</TT> specifiers</td>
     <td class="full" align="center">Clang 4 (C++11 onwards)</td>
   </tr>
   <tr class="open" id="1331">
-    <td><a href="http://wg21.link/cwg1331">1331</a></td>
+    <td><a href="https://wg21.link/cwg1331">1331</a></td>
     <td>extension</td>
     <td><TT>const</TT> mismatch with defaulted copy constructor</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="1332">
-    <td><a href="http://wg21.link/cwg1332">1332</a></td>
+    <td><a href="https://wg21.link/cwg1332">1332</a></td>
     <td>drafting</td>
     <td>Handling of invalid universal-character-names</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1333">
-    <td><a href="http://wg21.link/cwg1333">1333</a></td>
+    <td><a href="https://wg21.link/cwg1333">1333</a></td>
     <td>CD3</td>
     <td>Omission of <TT>const</TT> in a defaulted copy constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1334">
-    <td><a href="http://wg21.link/cwg1334">1334</a></td>
+    <td><a href="https://wg21.link/cwg1334">1334</a></td>
     <td>NAD</td>
     <td>Layout compatibility and cv-qualification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1335">
-    <td><a href="http://wg21.link/cwg1335">1335</a></td>
+    <td><a href="https://wg21.link/cwg1335">1335</a></td>
     <td>drafting</td>
     <td>Stringizing, extended characters, and universal-character-names</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1336">
-    <td><a href="http://wg21.link/cwg1336">1336</a></td>
+    <td><a href="https://wg21.link/cwg1336">1336</a></td>
     <td>CD3</td>
     <td>Definition of &#8220;converting constructor&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1337">
-    <td><a href="http://wg21.link/cwg1337">1337</a></td>
+    <td><a href="https://wg21.link/cwg1337">1337</a></td>
     <td>dup</td>
     <td>Partial ordering and non-deduced parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1338">
-    <td><a href="http://wg21.link/cwg1338">1338</a></td>
+    <td><a href="https://wg21.link/cwg1338">1338</a></td>
     <td>CD4</td>
     <td>Aliasing and allocation functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1339">
-    <td><a href="http://wg21.link/cwg1339">1339</a></td>
+    <td><a href="https://wg21.link/cwg1339">1339</a></td>
     <td>NAD</td>
     <td>Parenthesized <I>braced-init-list</I> and arrays</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1340">
-    <td><a href="http://wg21.link/cwg1340">1340</a></td>
+    <td><a href="https://wg21.link/cwg1340">1340</a></td>
     <td>CD3</td>
     <td>Complete type in member pointer expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1341">
-    <td><a href="http://wg21.link/cwg1341">1341</a></td>
+    <td><a href="https://wg21.link/cwg1341">1341</a></td>
     <td>NAD</td>
     <td>Bit-field initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1342">
-    <td><a href="http://wg21.link/cwg1342">1342</a></td>
+    <td><a href="https://wg21.link/cwg1342">1342</a></td>
     <td>drafting</td>
     <td>Order of initialization with multiple declarators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1343">
-    <td><a href="http://wg21.link/cwg1343">1343</a></td>
+    <td><a href="https://wg21.link/cwg1343">1343</a></td>
     <td>C++17</td>
     <td>Sequencing of non-class initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1344">
-    <td><a href="http://wg21.link/cwg1344">1344</a></td>
+    <td><a href="https://wg21.link/cwg1344">1344</a></td>
     <td>C++14</td>
     <td>Adding new special member functions to a class via default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1345">
-    <td><a href="http://wg21.link/cwg1345">1345</a></td>
+    <td><a href="https://wg21.link/cwg1345">1345</a></td>
     <td>CD3</td>
     <td>Initialization of anonymous union class members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1346">
-    <td><a href="http://wg21.link/cwg1346">1346</a></td>
+    <td><a href="https://wg21.link/cwg1346">1346</a></td>
     <td>CD3</td>
     <td><I>expression-list</I> initializers and the <TT>auto</TT> specifier</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="1347">
-    <td><a href="http://wg21.link/cwg1347">1347</a></td>
+    <td><a href="https://wg21.link/cwg1347">1347</a></td>
     <td>CD3</td>
     <td>Consistency of <TT>auto</TT> in multiple-declarator declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="1348">
-    <td><a href="http://wg21.link/cwg1348">1348</a></td>
+    <td><a href="https://wg21.link/cwg1348">1348</a></td>
     <td>drafting</td>
     <td>Use of <TT>auto</TT> in a <I>trailing-return-type</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1349">
-    <td><a href="http://wg21.link/cwg1349">1349</a></td>
+    <td><a href="https://wg21.link/cwg1349">1349</a></td>
     <td>dup</td>
     <td>Consistency of alias template redeclarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1350">
-    <td><a href="http://wg21.link/cwg1350">1350</a></td>
+    <td><a href="https://wg21.link/cwg1350">1350</a></td>
     <td>CD3</td>
     <td>Incorrect exception specification for inherited constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1351">
-    <td><a href="http://wg21.link/cwg1351">1351</a></td>
+    <td><a href="https://wg21.link/cwg1351">1351</a></td>
     <td>CD4</td>
     <td>Problems with implicitly-declared <I>exception-specification</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1352">
-    <td><a href="http://wg21.link/cwg1352">1352</a></td>
+    <td><a href="https://wg21.link/cwg1352">1352</a></td>
     <td>CD3</td>
     <td>Inconsistent class scope and completeness rules</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1353">
-    <td><a href="http://wg21.link/cwg1353">1353</a></td>
+    <td><a href="https://wg21.link/cwg1353">1353</a></td>
     <td>drafting</td>
     <td>Array and variant members and deleted special member functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1354">
-    <td><a href="http://wg21.link/cwg1354">1354</a></td>
+    <td><a href="https://wg21.link/cwg1354">1354</a></td>
     <td>CD3</td>
     <td>Destructor exceptions for temporaries in noexcept expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1355">
-    <td><a href="http://wg21.link/cwg1355">1355</a></td>
+    <td><a href="https://wg21.link/cwg1355">1355</a></td>
     <td>CD3</td>
     <td>Aggregates and &#8220;user-provided&#8221; constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1356">
-    <td><a href="http://wg21.link/cwg1356">1356</a></td>
+    <td><a href="https://wg21.link/cwg1356">1356</a></td>
     <td>CD4</td>
     <td>Exception specifications of copy assignment operators with virtual bases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1357">
-    <td><a href="http://wg21.link/cwg1357">1357</a></td>
+    <td><a href="https://wg21.link/cwg1357">1357</a></td>
     <td>CD3</td>
     <td><I>brace-or-equal-initializer</I>s for function and typedef members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1358">
-    <td><a href="http://wg21.link/cwg1358">1358</a></td>
+    <td><a href="https://wg21.link/cwg1358">1358</a></td>
     <td>CD3</td>
     <td>Unintentionally ill-formed <TT>constexpr</TT> function template instances</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1359">
-    <td><a href="http://wg21.link/cwg1359">1359</a></td>
+    <td><a href="https://wg21.link/cwg1359">1359</a></td>
     <td>CD3</td>
     <td><TT>constexpr</TT> union constructors</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr class="open" id="1360">
-    <td><a href="http://wg21.link/cwg1360">1360</a></td>
+    <td><a href="https://wg21.link/cwg1360">1360</a></td>
     <td>drafting</td>
     <td><TT>constexpr</TT> defaulted default constructors</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1361">
-    <td><a href="http://wg21.link/cwg1361">1361</a></td>
+    <td><a href="https://wg21.link/cwg1361">1361</a></td>
     <td>CD3</td>
     <td>Requirement on <I>brace-or-equal-initializer</I>s of literal types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1362">
-    <td><a href="http://wg21.link/cwg1362">1362</a></td>
+    <td><a href="https://wg21.link/cwg1362">1362</a></td>
     <td>CD3</td>
     <td>Complete type required for implicit conversion to <TT>T&amp;</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1363">
-    <td><a href="http://wg21.link/cwg1363">1363</a></td>
+    <td><a href="https://wg21.link/cwg1363">1363</a></td>
     <td>CD3</td>
     <td>Triviality vs multiple default constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1364">
-    <td><a href="http://wg21.link/cwg1364">1364</a></td>
+    <td><a href="https://wg21.link/cwg1364">1364</a></td>
     <td>CD3</td>
     <td><TT>constexpr</TT> function parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1365">
-    <td><a href="http://wg21.link/cwg1365">1365</a></td>
+    <td><a href="https://wg21.link/cwg1365">1365</a></td>
     <td>CD3</td>
     <td>Calling undefined <TT>constexpr</TT> functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1366">
-    <td><a href="http://wg21.link/cwg1366">1366</a></td>
+    <td><a href="https://wg21.link/cwg1366">1366</a></td>
     <td>CD3</td>
     <td>Deleted <TT>constexpr</TT> constructors and virtual base classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1367">
-    <td><a href="http://wg21.link/cwg1367">1367</a></td>
+    <td><a href="https://wg21.link/cwg1367">1367</a></td>
     <td>CD3</td>
     <td>Use of <TT>this</TT> in a constant expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1368">
-    <td><a href="http://wg21.link/cwg1368">1368</a></td>
+    <td><a href="https://wg21.link/cwg1368">1368</a></td>
     <td>CD3</td>
     <td>Value initialization and defaulted constructors (part 2)</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1369">
-    <td><a href="http://wg21.link/cwg1369">1369</a></td>
+    <td><a href="https://wg21.link/cwg1369">1369</a></td>
     <td>CD3</td>
     <td>Function invocation substitution of <TT>this</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1370">
-    <td><a href="http://wg21.link/cwg1370">1370</a></td>
+    <td><a href="https://wg21.link/cwg1370">1370</a></td>
     <td>CD3</td>
     <td><I>identifier-list</I> cannot contain ellipsis</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1371">
-    <td><a href="http://wg21.link/cwg1371">1371</a></td>
+    <td><a href="https://wg21.link/cwg1371">1371</a></td>
     <td>NAD</td>
     <td>Deduction from <TT>T&amp;&amp;</TT> in return types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1372">
-    <td><a href="http://wg21.link/cwg1372">1372</a></td>
+    <td><a href="https://wg21.link/cwg1372">1372</a></td>
     <td>CD3</td>
     <td>Cross-references incorrect in conversion function template argument deduction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1373">
-    <td><a href="http://wg21.link/cwg1373">1373</a></td>
+    <td><a href="https://wg21.link/cwg1373">1373</a></td>
     <td>dup</td>
     <td>Overload resolution changes matching reference-binding changes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1374">
-    <td><a href="http://wg21.link/cwg1374">1374</a></td>
+    <td><a href="https://wg21.link/cwg1374">1374</a></td>
     <td>CD3</td>
     <td>Qualification conversion vs difference in reference binding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1375">
-    <td><a href="http://wg21.link/cwg1375">1375</a></td>
+    <td><a href="https://wg21.link/cwg1375">1375</a></td>
     <td>CD3</td>
     <td>Reference to anonymous union?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1376">
-    <td><a href="http://wg21.link/cwg1376">1376</a></td>
+    <td><a href="https://wg21.link/cwg1376">1376</a></td>
     <td>C++14</td>
     <td><TT>static_cast</TT> of temporary to rvalue reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1377">
-    <td><a href="http://wg21.link/cwg1377">1377</a></td>
+    <td><a href="https://wg21.link/cwg1377">1377</a></td>
     <td>dup</td>
     <td>Access declarations not mentioned in Annex C</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1378">
-    <td><a href="http://wg21.link/cwg1378">1378</a></td>
+    <td><a href="https://wg21.link/cwg1378">1378</a></td>
     <td>open</td>
     <td>When is an instantiation required?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1379">
-    <td><a href="http://wg21.link/cwg1379">1379</a></td>
+    <td><a href="https://wg21.link/cwg1379">1379</a></td>
     <td>NAD</td>
     <td>Is <TT>std::initializer_list</TT> an aggregate?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1380">
-    <td><a href="http://wg21.link/cwg1380">1380</a></td>
+    <td><a href="https://wg21.link/cwg1380">1380</a></td>
     <td>CD3</td>
     <td>Type definitions in <I>template-parameter</I> <I>parameter-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1381">
-    <td><a href="http://wg21.link/cwg1381">1381</a></td>
+    <td><a href="https://wg21.link/cwg1381">1381</a></td>
     <td>CD3</td>
     <td>Implicitly-declared special member functions and default <TT>nothrow</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1382">
-    <td><a href="http://wg21.link/cwg1382">1382</a></td>
+    <td><a href="https://wg21.link/cwg1382">1382</a></td>
     <td>CD3</td>
     <td>Dead code for constructor names</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1383">
-    <td><a href="http://wg21.link/cwg1383">1383</a></td>
+    <td><a href="https://wg21.link/cwg1383">1383</a></td>
     <td>CD3</td>
     <td>Clarifying discarded-value expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1384">
-    <td><a href="http://wg21.link/cwg1384">1384</a></td>
+    <td><a href="https://wg21.link/cwg1384">1384</a></td>
     <td>NAD</td>
     <td><TT>reinterpret_cast</TT> in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1385">
-    <td><a href="http://wg21.link/cwg1385">1385</a></td>
+    <td><a href="https://wg21.link/cwg1385">1385</a></td>
     <td>CD3</td>
     <td>Syntactic forms of conversion functions for surrogate call functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1386">
-    <td><a href="http://wg21.link/cwg1386">1386</a></td>
+    <td><a href="https://wg21.link/cwg1386">1386</a></td>
     <td>NAD</td>
     <td>Explicitly-specified partial argument list with multiple parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1387">
-    <td><a href="http://wg21.link/cwg1387">1387</a></td>
+    <td><a href="https://wg21.link/cwg1387">1387</a></td>
     <td>CD3</td>
     <td>Missing non-deduced context for <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1388">
-    <td><a href="http://wg21.link/cwg1388">1388</a></td>
+    <td><a href="https://wg21.link/cwg1388">1388</a></td>
     <td>CD3</td>
     <td>Missing non-deduced context following a function parameter pack</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="1389">
-    <td><a href="http://wg21.link/cwg1389">1389</a></td>
+    <td><a href="https://wg21.link/cwg1389">1389</a></td>
     <td>NAD</td>
     <td>Recursive reference in <I>trailing-return-type</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1390">
-    <td><a href="http://wg21.link/cwg1390">1390</a></td>
+    <td><a href="https://wg21.link/cwg1390">1390</a></td>
     <td>drafting</td>
     <td>Dependency of alias template specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1391">
-    <td><a href="http://wg21.link/cwg1391">1391</a></td>
+    <td><a href="https://wg21.link/cwg1391">1391</a></td>
     <td>CD4</td>
     <td>Conversions to parameter types with non-deduced template arguments</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="1392">
-    <td><a href="http://wg21.link/cwg1392">1392</a></td>
+    <td><a href="https://wg21.link/cwg1392">1392</a></td>
     <td>CD3</td>
     <td>Explicit conversion functions for references and non-references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1393">
-    <td><a href="http://wg21.link/cwg1393">1393</a></td>
+    <td><a href="https://wg21.link/cwg1393">1393</a></td>
     <td>extension</td>
     <td>Pack expansions in <I>using-declaration</I>s</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1394">
-    <td><a href="http://wg21.link/cwg1394">1394</a></td>
+    <td><a href="https://wg21.link/cwg1394">1394</a></td>
     <td>CD3</td>
     <td>Incomplete types as parameters of deleted functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1395">
-    <td><a href="http://wg21.link/cwg1395">1395</a></td>
+    <td><a href="https://wg21.link/cwg1395">1395</a></td>
     <td>C++17</td>
     <td>Partial ordering of variadic templates reconsidered</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1396">
-    <td><a href="http://wg21.link/cwg1396">1396</a></td>
+    <td><a href="https://wg21.link/cwg1396">1396</a></td>
     <td>drafting</td>
     <td>Deferred instantiation and checking of non-static data member initializers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1397">
-    <td><a href="http://wg21.link/cwg1397">1397</a></td>
+    <td><a href="https://wg21.link/cwg1397">1397</a></td>
     <td>CD4</td>
     <td>Class completeness in non-static data member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1398">
-    <td><a href="http://wg21.link/cwg1398">1398</a></td>
+    <td><a href="https://wg21.link/cwg1398">1398</a></td>
     <td>CD3</td>
     <td>Non-type template parameters of type <TT>std::nullptr_t</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1399">
-    <td><a href="http://wg21.link/cwg1399">1399</a></td>
+    <td><a href="https://wg21.link/cwg1399">1399</a></td>
     <td>CD3</td>
     <td>Deduction with multiple function parameter packs</td>
     <td class="full" align="center">Duplicate of <a href="#1388">1388</a></td>
   </tr>
   <tr id="1400">
-    <td><a href="http://wg21.link/cwg1400">1400</a></td>
+    <td><a href="https://wg21.link/cwg1400">1400</a></td>
     <td>NAD</td>
     <td>Function pointer equality</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1401">
-    <td><a href="http://wg21.link/cwg1401">1401</a></td>
+    <td><a href="https://wg21.link/cwg1401">1401</a></td>
     <td>CD3</td>
     <td>Similar types and reference compatibility</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1402">
-    <td><a href="http://wg21.link/cwg1402">1402</a></td>
+    <td><a href="https://wg21.link/cwg1402">1402</a></td>
     <td>CD3</td>
     <td>Move functions too often deleted</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1403">
-    <td><a href="http://wg21.link/cwg1403">1403</a></td>
+    <td><a href="https://wg21.link/cwg1403">1403</a></td>
     <td>open</td>
     <td>Universal-character-names in comments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1404">
-    <td><a href="http://wg21.link/cwg1404">1404</a></td>
+    <td><a href="https://wg21.link/cwg1404">1404</a></td>
     <td>drafting</td>
     <td>Object reallocation in unions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1405">
-    <td><a href="http://wg21.link/cwg1405">1405</a></td>
+    <td><a href="https://wg21.link/cwg1405">1405</a></td>
     <td>CD3</td>
     <td><TT>constexpr</TT> and mutable members of literal types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1406">
-    <td><a href="http://wg21.link/cwg1406">1406</a></td>
+    <td><a href="https://wg21.link/cwg1406">1406</a></td>
     <td>CD3</td>
     <td><I>ref-qualifier</I>s and added parameters of non-static member function templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1407">
-    <td><a href="http://wg21.link/cwg1407">1407</a></td>
+    <td><a href="https://wg21.link/cwg1407">1407</a></td>
     <td>NAD</td>
     <td>Integral to <TT>bool</TT> conversion in converted constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1408">
-    <td><a href="http://wg21.link/cwg1408">1408</a></td>
+    <td><a href="https://wg21.link/cwg1408">1408</a></td>
     <td>CD3</td>
     <td>What is &#8220;the same aggregate initialization?&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1409">
-    <td><a href="http://wg21.link/cwg1409">1409</a></td>
+    <td><a href="https://wg21.link/cwg1409">1409</a></td>
     <td>CD3</td>
     <td>What is the second standard conversion sequence of a list-initialization sequence?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1410">
-    <td><a href="http://wg21.link/cwg1410">1410</a></td>
+    <td><a href="https://wg21.link/cwg1410">1410</a></td>
     <td>CD3</td>
     <td>Reference overload tiebreakers should apply to rvalue references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1411">
-    <td><a href="http://wg21.link/cwg1411">1411</a></td>
+    <td><a href="https://wg21.link/cwg1411">1411</a></td>
     <td>CD3</td>
     <td>More on global scope <TT>::</TT> in <I>nested-name-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1412">
-    <td><a href="http://wg21.link/cwg1412">1412</a></td>
+    <td><a href="https://wg21.link/cwg1412">1412</a></td>
     <td>CD3</td>
     <td>Problems in specifying pointer conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1413">
-    <td><a href="http://wg21.link/cwg1413">1413</a></td>
+    <td><a href="https://wg21.link/cwg1413">1413</a></td>
     <td>CD3</td>
     <td>Missing cases of value-dependency</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1414">
-    <td><a href="http://wg21.link/cwg1414">1414</a></td>
+    <td><a href="https://wg21.link/cwg1414">1414</a></td>
     <td>drafting</td>
     <td>Binding an rvalue reference to a reference-unrelated lvalue</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1415">
-    <td><a href="http://wg21.link/cwg1415">1415</a></td>
+    <td><a href="https://wg21.link/cwg1415">1415</a></td>
     <td>CD3</td>
     <td>Missing prohibition of block-scope definition of <TT>extern</TT> object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1416">
-    <td><a href="http://wg21.link/cwg1416">1416</a></td>
+    <td><a href="https://wg21.link/cwg1416">1416</a></td>
     <td>CD3</td>
     <td>Function cv-qualifiers and <TT>typeid</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1417">
-    <td><a href="http://wg21.link/cwg1417">1417</a></td>
+    <td><a href="https://wg21.link/cwg1417">1417</a></td>
     <td>C++14</td>
     <td>Pointers/references to functions with cv-qualifiers or <I>ref-qualifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1418">
-    <td><a href="http://wg21.link/cwg1418">1418</a></td>
+    <td><a href="https://wg21.link/cwg1418">1418</a></td>
     <td>CD3</td>
     <td>Type of <TT>initializer_list</TT> backing array</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1419">
-    <td><a href="http://wg21.link/cwg1419">1419</a></td>
+    <td><a href="https://wg21.link/cwg1419">1419</a></td>
     <td>NAD</td>
     <td>Evaluation order in aggregate initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1420">
-    <td><a href="http://wg21.link/cwg1420">1420</a></td>
+    <td><a href="https://wg21.link/cwg1420">1420</a></td>
     <td>NAD</td>
     <td>Abstract final classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1421">
-    <td><a href="http://wg21.link/cwg1421">1421</a></td>
+    <td><a href="https://wg21.link/cwg1421">1421</a></td>
     <td>NAD</td>
     <td>Full expressions and aggregate initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1422">
-    <td><a href="http://wg21.link/cwg1422">1422</a></td>
+    <td><a href="https://wg21.link/cwg1422">1422</a></td>
     <td>dup</td>
     <td>Type of character literals containing universal-character-names</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1423">
-    <td><a href="http://wg21.link/cwg1423">1423</a></td>
+    <td><a href="https://wg21.link/cwg1423">1423</a></td>
     <td>CD3</td>
     <td>Convertibility of <TT>nullptr</TT> to <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1424">
-    <td><a href="http://wg21.link/cwg1424">1424</a></td>
+    <td><a href="https://wg21.link/cwg1424">1424</a></td>
     <td>C++14</td>
     <td>When must sub-object destructors be accessible?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1425">
-    <td><a href="http://wg21.link/cwg1425">1425</a></td>
+    <td><a href="https://wg21.link/cwg1425">1425</a></td>
     <td>CD3</td>
     <td>Base-class subobjects of standard-layout structs</td>
     <td class="na" align="center">N/A (ABI constraint)</td>
   </tr>
   <tr class="open" id="1426">
-    <td><a href="http://wg21.link/cwg1426">1426</a></td>
+    <td><a href="https://wg21.link/cwg1426">1426</a></td>
     <td>extension</td>
     <td>Allowing additional parameter types in defaulted functions</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1427">
-    <td><a href="http://wg21.link/cwg1427">1427</a></td>
+    <td><a href="https://wg21.link/cwg1427">1427</a></td>
     <td>NAD</td>
     <td>Default constructor and deleted or inaccessible destructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1428">
-    <td><a href="http://wg21.link/cwg1428">1428</a></td>
+    <td><a href="https://wg21.link/cwg1428">1428</a></td>
     <td>CD3</td>
     <td>Dynamic const objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1429">
-    <td><a href="http://wg21.link/cwg1429">1429</a></td>
+    <td><a href="https://wg21.link/cwg1429">1429</a></td>
     <td>NAD</td>
     <td>Scope of a member template's template parameter</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1430">
-    <td><a href="http://wg21.link/cwg1430">1430</a></td>
+    <td><a href="https://wg21.link/cwg1430">1430</a></td>
     <td>drafting</td>
     <td>Pack expansion into fixed alias template parameter list</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1431">
-    <td><a href="http://wg21.link/cwg1431">1431</a></td>
+    <td><a href="https://wg21.link/cwg1431">1431</a></td>
     <td>CD3</td>
     <td>Exceptions from other than <I>throw-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1432">
-    <td><a href="http://wg21.link/cwg1432">1432</a></td>
+    <td><a href="https://wg21.link/cwg1432">1432</a></td>
     <td>drafting</td>
     <td>Newly-ambiguous variadic template expansions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1433">
-    <td><a href="http://wg21.link/cwg1433">1433</a></td>
+    <td><a href="https://wg21.link/cwg1433">1433</a></td>
     <td>extension</td>
     <td><I>trailing-return-type</I> and point of declaration</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1434">
-    <td><a href="http://wg21.link/cwg1434">1434</a></td>
+    <td><a href="https://wg21.link/cwg1434">1434</a></td>
     <td>NAD</td>
     <td>Parenthesized <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1435">
-    <td><a href="http://wg21.link/cwg1435">1435</a></td>
+    <td><a href="https://wg21.link/cwg1435">1435</a></td>
     <td>CD3</td>
     <td><I>template-id</I> as the declarator for a class template constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1436">
-    <td><a href="http://wg21.link/cwg1436">1436</a></td>
+    <td><a href="https://wg21.link/cwg1436">1436</a></td>
     <td>drafting</td>
     <td>Interaction of constant expression changes with preprocessor expressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1437">
-    <td><a href="http://wg21.link/cwg1437">1437</a></td>
+    <td><a href="https://wg21.link/cwg1437">1437</a></td>
     <td>CD3</td>
     <td><TT>alignas</TT> in <I>alias-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1438">
-    <td><a href="http://wg21.link/cwg1438">1438</a></td>
+    <td><a href="https://wg21.link/cwg1438">1438</a></td>
     <td>CD3</td>
     <td>Non-dereference use of invalid pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1439">
-    <td><a href="http://wg21.link/cwg1439">1439</a></td>
+    <td><a href="https://wg21.link/cwg1439">1439</a></td>
     <td>CD3</td>
     <td>Lookup and friend template declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1440">
-    <td><a href="http://wg21.link/cwg1440">1440</a></td>
+    <td><a href="https://wg21.link/cwg1440">1440</a></td>
     <td>CD3</td>
     <td>Acceptable <I>decltype-specifier</I>s used as <I>nested-name-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1441">
-    <td><a href="http://wg21.link/cwg1441">1441</a></td>
+    <td><a href="https://wg21.link/cwg1441">1441</a></td>
     <td>C++14</td>
     <td>Unclear wording for signal handler restrictions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1442">
-    <td><a href="http://wg21.link/cwg1442">1442</a></td>
+    <td><a href="https://wg21.link/cwg1442">1442</a></td>
     <td>CD3</td>
     <td>Argument-dependent lookup in the range-based <TT>for</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1443">
-    <td><a href="http://wg21.link/cwg1443">1443</a></td>
+    <td><a href="https://wg21.link/cwg1443">1443</a></td>
     <td>NAD</td>
     <td>Default arguments and non-static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1444">
-    <td><a href="http://wg21.link/cwg1444">1444</a></td>
+    <td><a href="https://wg21.link/cwg1444">1444</a></td>
     <td>drafting</td>
     <td>Type adjustments of non-type template parameters</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1445">
-    <td><a href="http://wg21.link/cwg1445">1445</a></td>
+    <td><a href="https://wg21.link/cwg1445">1445</a></td>
     <td>dup</td>
     <td>Argument-dependent lookup of <TT>begin</TT> and <TT>end</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1446">
-    <td><a href="http://wg21.link/cwg1446">1446</a></td>
+    <td><a href="https://wg21.link/cwg1446">1446</a></td>
     <td>CD4</td>
     <td>Member function with no <I>ref-qualifier</I> and non-member function with rvalue reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1447">
-    <td><a href="http://wg21.link/cwg1447">1447</a></td>
+    <td><a href="https://wg21.link/cwg1447">1447</a></td>
     <td>CD3</td>
     <td><TT>static_cast</TT> of bit-field lvalue to rvalue reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1448">
-    <td><a href="http://wg21.link/cwg1448">1448</a></td>
+    <td><a href="https://wg21.link/cwg1448">1448</a></td>
     <td>NAD</td>
     <td>Integral values of type <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1449">
-    <td><a href="http://wg21.link/cwg1449">1449</a></td>
+    <td><a href="https://wg21.link/cwg1449">1449</a></td>
     <td>CD3</td>
     <td>Narrowing conversion of negative value to unsigned type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1450">
-    <td><a href="http://wg21.link/cwg1450">1450</a></td>
+    <td><a href="https://wg21.link/cwg1450">1450</a></td>
     <td>CD3</td>
     <td><TT>INT_MIN % -1</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1451">
-    <td><a href="http://wg21.link/cwg1451">1451</a></td>
+    <td><a href="https://wg21.link/cwg1451">1451</a></td>
     <td>extension</td>
     <td>Objects with no linkage in non-type template arguments</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="1452">
-    <td><a href="http://wg21.link/cwg1452">1452</a></td>
+    <td><a href="https://wg21.link/cwg1452">1452</a></td>
     <td>drafting</td>
     <td>Value-initialized objects may be constants</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1453">
-    <td><a href="http://wg21.link/cwg1453">1453</a></td>
+    <td><a href="https://wg21.link/cwg1453">1453</a></td>
     <td>CD3</td>
     <td>Volatile members in literal classes?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1454">
-    <td><a href="http://wg21.link/cwg1454">1454</a></td>
+    <td><a href="https://wg21.link/cwg1454">1454</a></td>
     <td>CD3</td>
     <td>Passing constants through <TT>constexpr</TT> functions via references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1455">
-    <td><a href="http://wg21.link/cwg1455">1455</a></td>
+    <td><a href="https://wg21.link/cwg1455">1455</a></td>
     <td>CD3</td>
     <td>Lvalue converted constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1456">
-    <td><a href="http://wg21.link/cwg1456">1456</a></td>
+    <td><a href="https://wg21.link/cwg1456">1456</a></td>
     <td>CD3</td>
     <td>Address constant expression designating the one-past-the-end address</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1457">
-    <td><a href="http://wg21.link/cwg1457">1457</a></td>
+    <td><a href="https://wg21.link/cwg1457">1457</a></td>
     <td>CD3</td>
     <td>Undefined behavior in left-shift</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1458">
-    <td><a href="http://wg21.link/cwg1458">1458</a></td>
+    <td><a href="https://wg21.link/cwg1458">1458</a></td>
     <td>CD3</td>
     <td>Address of incomplete type vs <TT>operator&amp;()</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1459">
-    <td><a href="http://wg21.link/cwg1459">1459</a></td>
+    <td><a href="https://wg21.link/cwg1459">1459</a></td>
     <td>open</td>
     <td>Reference-binding tiebreakers in overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1460">
-    <td><a href="http://wg21.link/cwg1460">1460</a></td>
+    <td><a href="https://wg21.link/cwg1460">1460</a></td>
     <td>C++14</td>
     <td>What is an empty union?</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="1461">
-    <td><a href="http://wg21.link/cwg1461">1461</a></td>
+    <td><a href="https://wg21.link/cwg1461">1461</a></td>
     <td>NAD</td>
     <td>Narrowing conversions to bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1462">
-    <td><a href="http://wg21.link/cwg1462">1462</a></td>
+    <td><a href="https://wg21.link/cwg1462">1462</a></td>
     <td>CD3</td>
     <td>Deduction failure vs &#8220;ill-formed, no diagnostic required&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1463">
-    <td><a href="http://wg21.link/cwg1463">1463</a></td>
+    <td><a href="https://wg21.link/cwg1463">1463</a></td>
     <td>extension</td>
     <td><TT>extern "C"</TT> alias templates</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1464">
-    <td><a href="http://wg21.link/cwg1464">1464</a></td>
+    <td><a href="https://wg21.link/cwg1464">1464</a></td>
     <td>CD3</td>
     <td>Negative array bound in a <I>new-expression</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1465">
-    <td><a href="http://wg21.link/cwg1465">1465</a></td>
+    <td><a href="https://wg21.link/cwg1465">1465</a></td>
     <td>CD4</td>
     <td><TT>noexcept</TT> and <TT>std::bad_array_new_length</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1466">
-    <td><a href="http://wg21.link/cwg1466">1466</a></td>
+    <td><a href="https://wg21.link/cwg1466">1466</a></td>
     <td>C++14</td>
     <td>Visible sequences of side effects are redundant</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1467">
-    <td><a href="http://wg21.link/cwg1467">1467</a></td>
+    <td><a href="https://wg21.link/cwg1467">1467</a></td>
     <td>CD4</td>
     <td>List-initialization of aggregate from same-type object</td>
     <td class="full" align="center">Clang 3.7 (C++11 onwards)</td>
   </tr>
   <tr class="open" id="1468">
-    <td><a href="http://wg21.link/cwg1468">1468</a></td>
+    <td><a href="https://wg21.link/cwg1468">1468</a></td>
     <td>drafting</td>
     <td><TT>typeid</TT>, overload resolution, and implicit lambda capture</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1469">
-    <td><a href="http://wg21.link/cwg1469">1469</a></td>
+    <td><a href="https://wg21.link/cwg1469">1469</a></td>
     <td>extension</td>
     <td>Omitted bound in array <I>new-expression</I></td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1470">
-    <td><a href="http://wg21.link/cwg1470">1470</a></td>
+    <td><a href="https://wg21.link/cwg1470">1470</a></td>
     <td>NAD</td>
     <td>Thread migration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1471">
-    <td><a href="http://wg21.link/cwg1471">1471</a></td>
+    <td><a href="https://wg21.link/cwg1471">1471</a></td>
     <td>CD3</td>
     <td>Nested type of non-dependent base</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1472">
-    <td><a href="http://wg21.link/cwg1472">1472</a></td>
+    <td><a href="https://wg21.link/cwg1472">1472</a></td>
     <td>CD3</td>
     <td>odr-use of reference variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1473">
-    <td><a href="http://wg21.link/cwg1473">1473</a></td>
+    <td><a href="https://wg21.link/cwg1473">1473</a></td>
     <td>CD3</td>
     <td>Syntax of <I>literal-operator-id</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1474">
-    <td><a href="http://wg21.link/cwg1474">1474</a></td>
+    <td><a href="https://wg21.link/cwg1474">1474</a></td>
     <td>NAD</td>
     <td>User-defined literals and <TT>&lt;inttypes.h&gt;</TT> format macros</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1475">
-    <td><a href="http://wg21.link/cwg1475">1475</a></td>
+    <td><a href="https://wg21.link/cwg1475">1475</a></td>
     <td>CD3</td>
     <td>Errors in <TT>[[carries_dependency]]</TT> example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1476">
-    <td><a href="http://wg21.link/cwg1476">1476</a></td>
+    <td><a href="https://wg21.link/cwg1476">1476</a></td>
     <td>CD3</td>
     <td>Definition of user-defined type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1477">
-    <td><a href="http://wg21.link/cwg1477">1477</a></td>
+    <td><a href="https://wg21.link/cwg1477">1477</a></td>
     <td>CD3</td>
     <td>Definition of a <TT>friend</TT> outside its namespace</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1478">
-    <td><a href="http://wg21.link/cwg1478">1478</a></td>
+    <td><a href="https://wg21.link/cwg1478">1478</a></td>
     <td>drafting</td>
     <td><TT>template</TT> keyword for dependent template template arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1479">
-    <td><a href="http://wg21.link/cwg1479">1479</a></td>
+    <td><a href="https://wg21.link/cwg1479">1479</a></td>
     <td>CD3</td>
     <td>Literal operators and default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1480">
-    <td><a href="http://wg21.link/cwg1480">1480</a></td>
+    <td><a href="https://wg21.link/cwg1480">1480</a></td>
     <td>CD3</td>
     <td>Constant initialization via non-constant temporary</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1481">
-    <td><a href="http://wg21.link/cwg1481">1481</a></td>
+    <td><a href="https://wg21.link/cwg1481">1481</a></td>
     <td>CD3</td>
     <td>Increment/decrement operators with reference parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1482">
-    <td><a href="http://wg21.link/cwg1482">1482</a></td>
+    <td><a href="https://wg21.link/cwg1482">1482</a></td>
     <td>CD3</td>
     <td>Point of declaration of enumeration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1483">
-    <td><a href="http://wg21.link/cwg1483">1483</a></td>
+    <td><a href="https://wg21.link/cwg1483">1483</a></td>
     <td>NAD</td>
     <td>Non-dependent <I>static_assert-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1484">
-    <td><a href="http://wg21.link/cwg1484">1484</a></td>
+    <td><a href="https://wg21.link/cwg1484">1484</a></td>
     <td>CD4</td>
     <td>Unused local classes of function templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1485">
-    <td><a href="http://wg21.link/cwg1485">1485</a></td>
+    <td><a href="https://wg21.link/cwg1485">1485</a></td>
     <td>drafting</td>
     <td>Out-of-class definition of member unscoped opaque enumeration</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1486">
-    <td><a href="http://wg21.link/cwg1486">1486</a></td>
+    <td><a href="https://wg21.link/cwg1486">1486</a></td>
     <td>drafting</td>
     <td>Base-derived conversion in member pointer deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1487">
-    <td><a href="http://wg21.link/cwg1487">1487</a></td>
+    <td><a href="https://wg21.link/cwg1487">1487</a></td>
     <td>CD3</td>
     <td>When are inheriting constructors declared?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1488">
-    <td><a href="http://wg21.link/cwg1488">1488</a></td>
+    <td><a href="https://wg21.link/cwg1488">1488</a></td>
     <td>drafting</td>
     <td><I>abstract-pack-declarator</I>s in <I>type-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1489">
-    <td><a href="http://wg21.link/cwg1489">1489</a></td>
+    <td><a href="https://wg21.link/cwg1489">1489</a></td>
     <td>CD3</td>
     <td>Is value-initialization of an array constant initialization?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1490">
-    <td><a href="http://wg21.link/cwg1490">1490</a></td>
+    <td><a href="https://wg21.link/cwg1490">1490</a></td>
     <td>CD4</td>
     <td>List-initialization from a string literal</td>
     <td class="full" align="center">Clang 3.7 (C++11 onwards)</td>
   </tr>
   <tr id="1491">
-    <td><a href="http://wg21.link/cwg1491">1491</a></td>
+    <td><a href="https://wg21.link/cwg1491">1491</a></td>
     <td>CD3</td>
     <td>Move construction and rvalue reference members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1492">
-    <td><a href="http://wg21.link/cwg1492">1492</a></td>
+    <td><a href="https://wg21.link/cwg1492">1492</a></td>
     <td>CD4</td>
     <td>Exception specifications on template destructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1493">
-    <td><a href="http://wg21.link/cwg1493">1493</a></td>
+    <td><a href="https://wg21.link/cwg1493">1493</a></td>
     <td>C++14</td>
     <td>Criteria for move-construction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1494">
-    <td><a href="http://wg21.link/cwg1494">1494</a></td>
+    <td><a href="https://wg21.link/cwg1494">1494</a></td>
     <td>CD3</td>
     <td>Temporary initialization for reference binding in list-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1495">
-    <td><a href="http://wg21.link/cwg1495">1495</a></td>
+    <td><a href="https://wg21.link/cwg1495">1495</a></td>
     <td>CD3</td>
     <td>Partial specialization of variadic class template</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="1496">
-    <td><a href="http://wg21.link/cwg1496">1496</a></td>
+    <td><a href="https://wg21.link/cwg1496">1496</a></td>
     <td>CD4</td>
     <td>Triviality with deleted and missing default constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1497">
-    <td><a href="http://wg21.link/cwg1497">1497</a></td>
+    <td><a href="https://wg21.link/cwg1497">1497</a></td>
     <td>NAD</td>
     <td>Aggregate initialization with parenthesized string literal</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1498">
-    <td><a href="http://wg21.link/cwg1498">1498</a></td>
+    <td><a href="https://wg21.link/cwg1498">1498</a></td>
     <td>dup</td>
     <td>Lifetime of temporaries in range-based <TT>for</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1499">
-    <td><a href="http://wg21.link/cwg1499">1499</a></td>
+    <td><a href="https://wg21.link/cwg1499">1499</a></td>
     <td>drafting</td>
     <td>Missing case for deleted move assignment operator</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1500">
-    <td><a href="http://wg21.link/cwg1500">1500</a></td>
+    <td><a href="https://wg21.link/cwg1500">1500</a></td>
     <td>open</td>
     <td>Name lookup of dependent conversion function</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1501">
-    <td><a href="http://wg21.link/cwg1501">1501</a></td>
+    <td><a href="https://wg21.link/cwg1501">1501</a></td>
     <td>NAD</td>
     <td>Nested braces in list-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1502">
-    <td><a href="http://wg21.link/cwg1502">1502</a></td>
+    <td><a href="https://wg21.link/cwg1502">1502</a></td>
     <td>CD3</td>
     <td>Value initialization of unions with member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1503">
-    <td><a href="http://wg21.link/cwg1503">1503</a></td>
+    <td><a href="https://wg21.link/cwg1503">1503</a></td>
     <td>CD3</td>
     <td>Exceptions during copy to exception object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1504">
-    <td><a href="http://wg21.link/cwg1504">1504</a></td>
+    <td><a href="https://wg21.link/cwg1504">1504</a></td>
     <td>CD3</td>
     <td>Pointer arithmetic after derived-base conversion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1505">
-    <td><a href="http://wg21.link/cwg1505">1505</a></td>
+    <td><a href="https://wg21.link/cwg1505">1505</a></td>
     <td>dup</td>
     <td>Direct binding of reference to temporary in list-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1506">
-    <td><a href="http://wg21.link/cwg1506">1506</a></td>
+    <td><a href="https://wg21.link/cwg1506">1506</a></td>
     <td>CD3</td>
     <td>Value category of <TT>initializer_list</TT> object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1507">
-    <td><a href="http://wg21.link/cwg1507">1507</a></td>
+    <td><a href="https://wg21.link/cwg1507">1507</a></td>
     <td>CD3</td>
     <td>Value initialization with trivial inaccessible default constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1508">
-    <td><a href="http://wg21.link/cwg1508">1508</a></td>
+    <td><a href="https://wg21.link/cwg1508">1508</a></td>
     <td>C++14</td>
     <td>Template initializer-list constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1509">
-    <td><a href="http://wg21.link/cwg1509">1509</a></td>
+    <td><a href="https://wg21.link/cwg1509">1509</a></td>
     <td>C++14</td>
     <td>Definition of &#8220;non-template function&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1510">
-    <td><a href="http://wg21.link/cwg1510">1510</a></td>
+    <td><a href="https://wg21.link/cwg1510">1510</a></td>
     <td>CD3</td>
     <td>cv-qualified references via <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1511">
-    <td><a href="http://wg21.link/cwg1511">1511</a></td>
+    <td><a href="https://wg21.link/cwg1511">1511</a></td>
     <td>CD3</td>
     <td><TT>const volatile</TT> variables and the one-definition rule</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1512">
-    <td><a href="http://wg21.link/cwg1512">1512</a></td>
+    <td><a href="https://wg21.link/cwg1512">1512</a></td>
     <td>CD3</td>
     <td>Pointer comparison vs qualification conversions</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr class="open" id="1513">
-    <td><a href="http://wg21.link/cwg1513">1513</a></td>
+    <td><a href="https://wg21.link/cwg1513">1513</a></td>
     <td>drafting</td>
     <td><TT>initializer_list</TT> deduction failure</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1514">
-    <td><a href="http://wg21.link/cwg1514">1514</a></td>
+    <td><a href="https://wg21.link/cwg1514">1514</a></td>
     <td>C++14</td>
     <td>Ambiguity between enumeration definition and zero-length bit-field</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1515">
-    <td><a href="http://wg21.link/cwg1515">1515</a></td>
+    <td><a href="https://wg21.link/cwg1515">1515</a></td>
     <td>CD3</td>
     <td>Modulo 2<SUP><I>n</I></SUP> arithmetic for implicitly-unsigned types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1516">
-    <td><a href="http://wg21.link/cwg1516">1516</a></td>
+    <td><a href="https://wg21.link/cwg1516">1516</a></td>
     <td>CD3</td>
     <td>Definition of &#8220;virtual function call&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1517">
-    <td><a href="http://wg21.link/cwg1517">1517</a></td>
+    <td><a href="https://wg21.link/cwg1517">1517</a></td>
     <td>drafting</td>
     <td>Unclear/missing description of behavior during construction/destruction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1518">
-    <td><a href="http://wg21.link/cwg1518">1518</a></td>
+    <td><a href="https://wg21.link/cwg1518">1518</a></td>
     <td>CD4</td>
     <td>Explicit default constructors and copy-list-initialization</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="1519">
-    <td><a href="http://wg21.link/cwg1519">1519</a></td>
+    <td><a href="https://wg21.link/cwg1519">1519</a></td>
     <td>NAD</td>
     <td>Conflicting default and variadic constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1520">
-    <td><a href="http://wg21.link/cwg1520">1520</a></td>
+    <td><a href="https://wg21.link/cwg1520">1520</a></td>
     <td>NAD</td>
     <td>Alias template specialization vs pack expansion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1521">
-    <td><a href="http://wg21.link/cwg1521">1521</a></td>
+    <td><a href="https://wg21.link/cwg1521">1521</a></td>
     <td>drafting</td>
     <td><TT>T{</TT><I>expr</I><TT>}</TT> with reference types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1522">
-    <td><a href="http://wg21.link/cwg1522">1522</a></td>
+    <td><a href="https://wg21.link/cwg1522">1522</a></td>
     <td>CD3</td>
     <td>Access checking for <TT>initializer_list</TT> array initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1523">
-    <td><a href="http://wg21.link/cwg1523">1523</a></td>
+    <td><a href="https://wg21.link/cwg1523">1523</a></td>
     <td>DRWP</td>
     <td>Point of declaration in range-based <TT>for</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1524">
-    <td><a href="http://wg21.link/cwg1524">1524</a></td>
+    <td><a href="https://wg21.link/cwg1524">1524</a></td>
     <td>drafting</td>
     <td>Incompletely-defined class template base</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1525">
-    <td><a href="http://wg21.link/cwg1525">1525</a></td>
+    <td><a href="https://wg21.link/cwg1525">1525</a></td>
     <td>NAD</td>
     <td>Array bound inference in temporary array</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1526">
-    <td><a href="http://wg21.link/cwg1526">1526</a></td>
+    <td><a href="https://wg21.link/cwg1526">1526</a></td>
     <td>dup</td>
     <td>Dependent-class lookup in the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1527">
-    <td><a href="http://wg21.link/cwg1527">1527</a></td>
+    <td><a href="https://wg21.link/cwg1527">1527</a></td>
     <td>CD3</td>
     <td>Assignment from <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1528">
-    <td><a href="http://wg21.link/cwg1528">1528</a></td>
+    <td><a href="https://wg21.link/cwg1528">1528</a></td>
     <td>CD3</td>
     <td>Repeated <I>cv-qualifier</I>s in declarators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1529">
-    <td><a href="http://wg21.link/cwg1529">1529</a></td>
+    <td><a href="https://wg21.link/cwg1529">1529</a></td>
     <td>drafting</td>
     <td>Nomenclature for variable vs reference non-static data member</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1530">
-    <td><a href="http://wg21.link/cwg1530">1530</a></td>
+    <td><a href="https://wg21.link/cwg1530">1530</a></td>
     <td>drafting</td>
     <td>Member access in out-of-lifetime objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1531">
-    <td><a href="http://wg21.link/cwg1531">1531</a></td>
+    <td><a href="https://wg21.link/cwg1531">1531</a></td>
     <td>CD3</td>
     <td>Definition of &#8220;access&#8221; (verb)</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1532">
-    <td><a href="http://wg21.link/cwg1532">1532</a></td>
+    <td><a href="https://wg21.link/cwg1532">1532</a></td>
     <td>CD3</td>
     <td>Explicit instantiation and member templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1533">
-    <td><a href="http://wg21.link/cwg1533">1533</a></td>
+    <td><a href="https://wg21.link/cwg1533">1533</a></td>
     <td>CD3</td>
     <td>Function pack expansion for member initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1534">
-    <td><a href="http://wg21.link/cwg1534">1534</a></td>
+    <td><a href="https://wg21.link/cwg1534">1534</a></td>
     <td>dup</td>
     <td>cv-qualification of prvalue of type &#8220;array of class&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1535">
-    <td><a href="http://wg21.link/cwg1535">1535</a></td>
+    <td><a href="https://wg21.link/cwg1535">1535</a></td>
     <td>CD3</td>
     <td><TT>typeid</TT> in core constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1536">
-    <td><a href="http://wg21.link/cwg1536">1536</a></td>
+    <td><a href="https://wg21.link/cwg1536">1536</a></td>
     <td>drafting</td>
     <td>Overload resolution with temporary from initializer list</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1537">
-    <td><a href="http://wg21.link/cwg1537">1537</a></td>
+    <td><a href="https://wg21.link/cwg1537">1537</a></td>
     <td>CD3</td>
     <td>Optional compile-time evaluation of constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1538">
-    <td><a href="http://wg21.link/cwg1538">1538</a></td>
+    <td><a href="https://wg21.link/cwg1538">1538</a></td>
     <td>CD3</td>
     <td>C-style cast in <I>braced-init-list</I> assignment</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1539">
-    <td><a href="http://wg21.link/cwg1539">1539</a></td>
+    <td><a href="https://wg21.link/cwg1539">1539</a></td>
     <td>CD3</td>
     <td>Definition of &#8220;character type&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1540">
-    <td><a href="http://wg21.link/cwg1540">1540</a></td>
+    <td><a href="https://wg21.link/cwg1540">1540</a></td>
     <td>NAD</td>
     <td>Use of address constants in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1541">
-    <td><a href="http://wg21.link/cwg1541">1541</a></td>
+    <td><a href="https://wg21.link/cwg1541">1541</a></td>
     <td>CD3</td>
     <td><I>cv</I> <TT>void</TT> return types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1542">
-    <td><a href="http://wg21.link/cwg1542">1542</a></td>
+    <td><a href="https://wg21.link/cwg1542">1542</a></td>
     <td>drafting</td>
     <td>Compound assignment of <I>braced-init-list</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1543">
-    <td><a href="http://wg21.link/cwg1543">1543</a></td>
+    <td><a href="https://wg21.link/cwg1543">1543</a></td>
     <td>CD3</td>
     <td>Implicit conversion sequence for empty initializer list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1544">
-    <td><a href="http://wg21.link/cwg1544">1544</a></td>
+    <td><a href="https://wg21.link/cwg1544">1544</a></td>
     <td>CD3</td>
     <td>Linkage of member of unnamed namespace</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1545">
-    <td><a href="http://wg21.link/cwg1545">1545</a></td>
+    <td><a href="https://wg21.link/cwg1545">1545</a></td>
     <td>drafting</td>
     <td><TT>friend</TT> function templates defined in class templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1546">
-    <td><a href="http://wg21.link/cwg1546">1546</a></td>
+    <td><a href="https://wg21.link/cwg1546">1546</a></td>
     <td>NAD</td>
     <td>Errors in function template default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1547">
-    <td><a href="http://wg21.link/cwg1547">1547</a></td>
+    <td><a href="https://wg21.link/cwg1547">1547</a></td>
     <td>NAD</td>
     <td><TT>typename</TT> keyword in <I>alias-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1548">
-    <td><a href="http://wg21.link/cwg1548">1548</a></td>
+    <td><a href="https://wg21.link/cwg1548">1548</a></td>
     <td>drafting</td>
     <td>Copy/move construction and conversion functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1549">
-    <td><a href="http://wg21.link/cwg1549">1549</a></td>
+    <td><a href="https://wg21.link/cwg1549">1549</a></td>
     <td>open</td>
     <td>Overloaded comma operator with <TT>void</TT> operand</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1550">
-    <td><a href="http://wg21.link/cwg1550">1550</a></td>
+    <td><a href="https://wg21.link/cwg1550">1550</a></td>
     <td>CD3</td>
     <td>Parenthesized <I>throw-expression</I> operand of <I>conditional-expression</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1551">
-    <td><a href="http://wg21.link/cwg1551">1551</a></td>
+    <td><a href="https://wg21.link/cwg1551">1551</a></td>
     <td>C++14</td>
     <td>Wording problems in <I>using-declaration</I> specification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1552">
-    <td><a href="http://wg21.link/cwg1552">1552</a></td>
+    <td><a href="https://wg21.link/cwg1552">1552</a></td>
     <td>CD4</td>
     <td><I>exception-specification</I>s and defaulted special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1553">
-    <td><a href="http://wg21.link/cwg1553">1553</a></td>
+    <td><a href="https://wg21.link/cwg1553">1553</a></td>
     <td>CD3</td>
     <td><TT>sizeof</TT> and xvalue bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1554">
-    <td><a href="http://wg21.link/cwg1554">1554</a></td>
+    <td><a href="https://wg21.link/cwg1554">1554</a></td>
     <td>drafting</td>
     <td>Access and alias templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1555">
-    <td><a href="http://wg21.link/cwg1555">1555</a></td>
+    <td><a href="https://wg21.link/cwg1555">1555</a></td>
     <td>extension</td>
     <td>Language linkage and function type compatibility</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1556">
-    <td><a href="http://wg21.link/cwg1556">1556</a></td>
+    <td><a href="https://wg21.link/cwg1556">1556</a></td>
     <td>CD3</td>
     <td>Constructors and explicit conversion functions in direct initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1557">
-    <td><a href="http://wg21.link/cwg1557">1557</a></td>
+    <td><a href="https://wg21.link/cwg1557">1557</a></td>
     <td>CD3</td>
     <td>Language linkage of converted lambda function pointer</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1558">
-    <td><a href="http://wg21.link/cwg1558">1558</a></td>
+    <td><a href="https://wg21.link/cwg1558">1558</a></td>
     <td>CD4</td>
     <td>Unused arguments in alias template specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1559">
-    <td><a href="http://wg21.link/cwg1559">1559</a></td>
+    <td><a href="https://wg21.link/cwg1559">1559</a></td>
     <td>CD3</td>
     <td>String too long in initializer list of <I>new-expression</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1560">
-    <td><a href="http://wg21.link/cwg1560">1560</a></td>
+    <td><a href="https://wg21.link/cwg1560">1560</a></td>
     <td>CD3</td>
     <td>Gratuitous lvalue-to-rvalue conversion in <I>conditional-expression</I> with <I>throw-expression</I> operand</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr class="open" id="1561">
-    <td><a href="http://wg21.link/cwg1561">1561</a></td>
+    <td><a href="https://wg21.link/cwg1561">1561</a></td>
     <td>extension</td>
     <td>Aggregates with empty base classes</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1562">
-    <td><a href="http://wg21.link/cwg1562">1562</a></td>
+    <td><a href="https://wg21.link/cwg1562">1562</a></td>
     <td>C++14</td>
     <td>Non-static data member initializers and union <I>ctor-initializer</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1563">
-    <td><a href="http://wg21.link/cwg1563">1563</a></td>
+    <td><a href="https://wg21.link/cwg1563">1563</a></td>
     <td>CD3</td>
     <td>List-initialization and overloaded function disambiguation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1564">
-    <td><a href="http://wg21.link/cwg1564">1564</a></td>
+    <td><a href="https://wg21.link/cwg1564">1564</a></td>
     <td>NAD</td>
     <td>Template argument deduction from an initializer list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1565">
-    <td><a href="http://wg21.link/cwg1565">1565</a></td>
+    <td><a href="https://wg21.link/cwg1565">1565</a></td>
     <td>NAD</td>
     <td>Copy elision and lifetime of <TT>initializer_list</TT> underlying array</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1566">
-    <td><a href="http://wg21.link/cwg1566">1566</a></td>
+    <td><a href="https://wg21.link/cwg1566">1566</a></td>
     <td>NAD</td>
     <td>Should <TT>new std::initializer_list&lt;T&gt;</TT> be ill-formed?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1567">
-    <td><a href="http://wg21.link/cwg1567">1567</a></td>
+    <td><a href="https://wg21.link/cwg1567">1567</a></td>
     <td>C++14</td>
     <td>Inheriting constructors and copy/move constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1568">
-    <td><a href="http://wg21.link/cwg1568">1568</a></td>
+    <td><a href="https://wg21.link/cwg1568">1568</a></td>
     <td>dup</td>
     <td>Temporary lifetime extension with intervening cast</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1569">
-    <td><a href="http://wg21.link/cwg1569">1569</a></td>
+    <td><a href="https://wg21.link/cwg1569">1569</a></td>
     <td>C++14</td>
     <td>Deducing a function parameter pack before ellipsis</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1570">
-    <td><a href="http://wg21.link/cwg1570">1570</a></td>
+    <td><a href="https://wg21.link/cwg1570">1570</a></td>
     <td>C++14</td>
     <td>Address of subobject as non-type template argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1571">
-    <td><a href="http://wg21.link/cwg1571">1571</a></td>
+    <td><a href="https://wg21.link/cwg1571">1571</a></td>
     <td>CD4</td>
     <td>cv-qualification for indirect reference binding via conversion function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1572">
-    <td><a href="http://wg21.link/cwg1572">1572</a></td>
+    <td><a href="https://wg21.link/cwg1572">1572</a></td>
     <td>CD4</td>
     <td>Incorrect example for rvalue reference binding via conversion function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1573">
-    <td><a href="http://wg21.link/cwg1573">1573</a></td>
+    <td><a href="https://wg21.link/cwg1573">1573</a></td>
     <td>CD4</td>
     <td>Inherited constructor characteristics</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1574">
-    <td><a href="http://wg21.link/cwg1574">1574</a></td>
+    <td><a href="https://wg21.link/cwg1574">1574</a></td>
     <td>NAD</td>
     <td>Explicitly-defaulted <TT>constexpr</TT> functions in wrapper templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1575">
-    <td><a href="http://wg21.link/cwg1575">1575</a></td>
+    <td><a href="https://wg21.link/cwg1575">1575</a></td>
     <td>C++14</td>
     <td>Incorrect definition of &#8220;strict pointer safety&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1576">
-    <td><a href="http://wg21.link/cwg1576">1576</a></td>
+    <td><a href="https://wg21.link/cwg1576">1576</a></td>
     <td>C++14</td>
     <td>Discarded-value volatile xvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1577">
-    <td><a href="http://wg21.link/cwg1577">1577</a></td>
+    <td><a href="https://wg21.link/cwg1577">1577</a></td>
     <td>NAD</td>
     <td>Unnecessary restrictions on partial specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1578">
-    <td><a href="http://wg21.link/cwg1578">1578</a></td>
+    <td><a href="https://wg21.link/cwg1578">1578</a></td>
     <td>NAD</td>
     <td>Value-initialization of aggregates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1579">
-    <td><a href="http://wg21.link/cwg1579">1579</a></td>
+    <td><a href="https://wg21.link/cwg1579">1579</a></td>
     <td>C++14</td>
     <td>Return by converting move constructor</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr class="open" id="1580">
-    <td><a href="http://wg21.link/cwg1580">1580</a></td>
+    <td><a href="https://wg21.link/cwg1580">1580</a></td>
     <td>drafting</td>
     <td>Default arguments in explicit instantiations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1581">
-    <td><a href="http://wg21.link/cwg1581">1581</a></td>
+    <td><a href="https://wg21.link/cwg1581">1581</a></td>
     <td>DRWP</td>
     <td>When are <TT>constexpr</TT> member functions defined?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1582">
-    <td><a href="http://wg21.link/cwg1582">1582</a></td>
+    <td><a href="https://wg21.link/cwg1582">1582</a></td>
     <td>drafting</td>
     <td>Template default arguments and deduction failure</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1583">
-    <td><a href="http://wg21.link/cwg1583">1583</a></td>
+    <td><a href="https://wg21.link/cwg1583">1583</a></td>
     <td>C++14</td>
     <td>Incorrect example of unspecified behavior</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1584">
-    <td><a href="http://wg21.link/cwg1584">1584</a></td>
+    <td><a href="https://wg21.link/cwg1584">1584</a></td>
     <td>drafting</td>
     <td>Deducing function types from cv-qualified types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1585">
-    <td><a href="http://wg21.link/cwg1585">1585</a></td>
+    <td><a href="https://wg21.link/cwg1585">1585</a></td>
     <td>NAD</td>
     <td>Value category of member access of rvalue reference member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1586">
-    <td><a href="http://wg21.link/cwg1586">1586</a></td>
+    <td><a href="https://wg21.link/cwg1586">1586</a></td>
     <td>NAD</td>
     <td>Naming a destructor via <TT>decltype</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1587">
-    <td><a href="http://wg21.link/cwg1587">1587</a></td>
+    <td><a href="https://wg21.link/cwg1587">1587</a></td>
     <td>C++14</td>
     <td><TT>constexpr</TT> initialization and nested anonymous unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1588">
-    <td><a href="http://wg21.link/cwg1588">1588</a></td>
+    <td><a href="https://wg21.link/cwg1588">1588</a></td>
     <td>CD3</td>
     <td>Deducing cv-qualified <TT>auto</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1589">
-    <td><a href="http://wg21.link/cwg1589">1589</a></td>
+    <td><a href="https://wg21.link/cwg1589">1589</a></td>
     <td>CD4</td>
     <td>Ambiguous ranking of list-initialization sequences</td>
     <td class="full" align="center">Clang 3.7 (C++11 onwards)</td>
   </tr>
   <tr id="1590">
-    <td><a href="http://wg21.link/cwg1590">1590</a></td>
+    <td><a href="https://wg21.link/cwg1590">1590</a></td>
     <td>CD4</td>
     <td>Bypassing non-copy/move constructor copying</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1591">
-    <td><a href="http://wg21.link/cwg1591">1591</a></td>
+    <td><a href="https://wg21.link/cwg1591">1591</a></td>
     <td>CD4</td>
     <td>Deducing array bound and element type from initializer list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1592">
-    <td><a href="http://wg21.link/cwg1592">1592</a></td>
+    <td><a href="https://wg21.link/cwg1592">1592</a></td>
     <td>C++14</td>
     <td>When do template parameters match?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1593">
-    <td><a href="http://wg21.link/cwg1593">1593</a></td>
+    <td><a href="https://wg21.link/cwg1593">1593</a></td>
     <td>C++14</td>
     <td>&#8220;Parameter type&#8221; of special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1594">
-    <td><a href="http://wg21.link/cwg1594">1594</a></td>
+    <td><a href="https://wg21.link/cwg1594">1594</a></td>
     <td>drafting</td>
     <td>Lazy declaration of special members vs overload errors</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1595">
-    <td><a href="http://wg21.link/cwg1595">1595</a></td>
+    <td><a href="https://wg21.link/cwg1595">1595</a></td>
     <td>C++14</td>
     <td>Constructors &#8220;involved in&#8221; subobject initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1596">
-    <td><a href="http://wg21.link/cwg1596">1596</a></td>
+    <td><a href="https://wg21.link/cwg1596">1596</a></td>
     <td>CD4</td>
     <td>Non-array objects as <TT>array[1]</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1597">
-    <td><a href="http://wg21.link/cwg1597">1597</a></td>
+    <td><a href="https://wg21.link/cwg1597">1597</a></td>
     <td>CD3</td>
     <td>Misleading <TT>constexpr</TT> example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1598">
-    <td><a href="http://wg21.link/cwg1598">1598</a></td>
+    <td><a href="https://wg21.link/cwg1598">1598</a></td>
     <td>C++14</td>
     <td>Criterion for equality of pointers to members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1599">
-    <td><a href="http://wg21.link/cwg1599">1599</a></td>
+    <td><a href="https://wg21.link/cwg1599">1599</a></td>
     <td>CD4</td>
     <td>Lifetime of <TT>initializer_list</TT> underlying array</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1600">
-    <td><a href="http://wg21.link/cwg1600">1600</a></td>
+    <td><a href="https://wg21.link/cwg1600">1600</a></td>
     <td>CD4</td>
     <td>Erroneous reference initialization in example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1601">
-    <td><a href="http://wg21.link/cwg1601">1601</a></td>
+    <td><a href="https://wg21.link/cwg1601">1601</a></td>
     <td>C++14</td>
     <td>Promotion of enumeration with fixed underlying type</td>
     <td class="svn" align="center">SVN</td>
   </tr>
   <tr class="open" id="1602">
-    <td><a href="http://wg21.link/cwg1602">1602</a></td>
+    <td><a href="https://wg21.link/cwg1602">1602</a></td>
     <td>open</td>
     <td>Linkage of specialization vs linkage of template arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1603">
-    <td><a href="http://wg21.link/cwg1603">1603</a></td>
+    <td><a href="https://wg21.link/cwg1603">1603</a></td>
     <td>CD4</td>
     <td>Errors resulting from giving unnamed namespaces internal linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1604">
-    <td><a href="http://wg21.link/cwg1604">1604</a></td>
+    <td><a href="https://wg21.link/cwg1604">1604</a></td>
     <td>C++14</td>
     <td>Double temporaries in reference initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1605">
-    <td><a href="http://wg21.link/cwg1605">1605</a></td>
+    <td><a href="https://wg21.link/cwg1605">1605</a></td>
     <td>CD3</td>
     <td>Misleading parenthetical comment for explicit destructor call</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1606">
-    <td><a href="http://wg21.link/cwg1606">1606</a></td>
+    <td><a href="https://wg21.link/cwg1606">1606</a></td>
     <td>NAD</td>
     <td><TT>sizeof</TT> closure class</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1607">
-    <td><a href="http://wg21.link/cwg1607">1607</a></td>
+    <td><a href="https://wg21.link/cwg1607">1607</a></td>
     <td>C++14</td>
     <td>Lambdas in template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1608">
-    <td><a href="http://wg21.link/cwg1608">1608</a></td>
+    <td><a href="https://wg21.link/cwg1608">1608</a></td>
     <td>C++14</td>
     <td>Operator lookup in trailing return type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1609">
-    <td><a href="http://wg21.link/cwg1609">1609</a></td>
+    <td><a href="https://wg21.link/cwg1609">1609</a></td>
     <td>open</td>
     <td>Default arguments and function parameter packs</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1610">
-    <td><a href="http://wg21.link/cwg1610">1610</a></td>
+    <td><a href="https://wg21.link/cwg1610">1610</a></td>
     <td>drafting</td>
     <td>Cv-qualification in deduction of reference to array</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1611">
-    <td><a href="http://wg21.link/cwg1611">1611</a></td>
+    <td><a href="https://wg21.link/cwg1611">1611</a></td>
     <td>C++14</td>
     <td>Deleted default constructor for abstract class</td>
     <td class="full" align="center">Duplicate of <a href="#1658">1658</a></td>
   </tr>
   <tr id="1612">
-    <td><a href="http://wg21.link/cwg1612">1612</a></td>
+    <td><a href="https://wg21.link/cwg1612">1612</a></td>
     <td>C++14</td>
     <td>Implicit lambda capture and anonymous unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1613">
-    <td><a href="http://wg21.link/cwg1613">1613</a></td>
+    <td><a href="https://wg21.link/cwg1613">1613</a></td>
     <td>C++14</td>
     <td>Constant expressions and lambda capture</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1614">
-    <td><a href="http://wg21.link/cwg1614">1614</a></td>
+    <td><a href="https://wg21.link/cwg1614">1614</a></td>
     <td>CD4</td>
     <td>Address of pure virtual function vs odr-use</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1615">
-    <td><a href="http://wg21.link/cwg1615">1615</a></td>
+    <td><a href="https://wg21.link/cwg1615">1615</a></td>
     <td>CD4</td>
     <td>Alignment of types, variables, and members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1616">
-    <td><a href="http://wg21.link/cwg1616">1616</a></td>
+    <td><a href="https://wg21.link/cwg1616">1616</a></td>
     <td>drafting</td>
     <td>Disambiguation parsing and template parameters</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1617">
-    <td><a href="http://wg21.link/cwg1617">1617</a></td>
+    <td><a href="https://wg21.link/cwg1617">1617</a></td>
     <td>open</td>
     <td><TT>alignas</TT> and non-defining declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1618">
-    <td><a href="http://wg21.link/cwg1618">1618</a></td>
+    <td><a href="https://wg21.link/cwg1618">1618</a></td>
     <td>C++14</td>
     <td>Gratuitously-unsigned underlying enum type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1619">
-    <td><a href="http://wg21.link/cwg1619">1619</a></td>
+    <td><a href="https://wg21.link/cwg1619">1619</a></td>
     <td>open</td>
     <td>Definition of current instantiation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1620">
-    <td><a href="http://wg21.link/cwg1620">1620</a></td>
+    <td><a href="https://wg21.link/cwg1620">1620</a></td>
     <td>open</td>
     <td>User-defined literals and extended integer types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1621">
-    <td><a href="http://wg21.link/cwg1621">1621</a></td>
+    <td><a href="https://wg21.link/cwg1621">1621</a></td>
     <td>drafting</td>
     <td>Member initializers in anonymous unions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1622">
-    <td><a href="http://wg21.link/cwg1622">1622</a></td>
+    <td><a href="https://wg21.link/cwg1622">1622</a></td>
     <td>C++17</td>
     <td>Empty aggregate initializer for union</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1623">
-    <td><a href="http://wg21.link/cwg1623">1623</a></td>
+    <td><a href="https://wg21.link/cwg1623">1623</a></td>
     <td>drafting</td>
     <td>Deleted default union constructor and member initializers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1624">
-    <td><a href="http://wg21.link/cwg1624">1624</a></td>
+    <td><a href="https://wg21.link/cwg1624">1624</a></td>
     <td>NAD</td>
     <td>Destruction of union members with member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1625">
-    <td><a href="http://wg21.link/cwg1625">1625</a></td>
+    <td><a href="https://wg21.link/cwg1625">1625</a></td>
     <td>open</td>
     <td>Adding spaces between tokens in stringizing</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1626">
-    <td><a href="http://wg21.link/cwg1626">1626</a></td>
+    <td><a href="https://wg21.link/cwg1626">1626</a></td>
     <td>drafting</td>
     <td><TT>constexpr</TT> member functions in <I>brace-or-equal-initializer</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1627">
-    <td><a href="http://wg21.link/cwg1627">1627</a></td>
+    <td><a href="https://wg21.link/cwg1627">1627</a></td>
     <td>NAD</td>
     <td>Agreement of dependent <TT>alignas</TT> specifiers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1628">
-    <td><a href="http://wg21.link/cwg1628">1628</a></td>
+    <td><a href="https://wg21.link/cwg1628">1628</a></td>
     <td>open</td>
     <td>Deallocation function templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1629">
-    <td><a href="http://wg21.link/cwg1629">1629</a></td>
+    <td><a href="https://wg21.link/cwg1629">1629</a></td>
     <td>C++14</td>
     <td>Can a closure class be a literal type?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1630">
-    <td><a href="http://wg21.link/cwg1630">1630</a></td>
+    <td><a href="https://wg21.link/cwg1630">1630</a></td>
     <td>CD4</td>
     <td>Multiple default constructor templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1631">
-    <td><a href="http://wg21.link/cwg1631">1631</a></td>
+    <td><a href="https://wg21.link/cwg1631">1631</a></td>
     <td>CD4</td>
     <td>Incorrect overload resolution for single-element <I>initializer-list</I></td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="1632">
-    <td><a href="http://wg21.link/cwg1632">1632</a></td>
+    <td><a href="https://wg21.link/cwg1632">1632</a></td>
     <td>DRWP</td>
     <td>Lambda capture in member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1633">
-    <td><a href="http://wg21.link/cwg1633">1633</a></td>
+    <td><a href="https://wg21.link/cwg1633">1633</a></td>
     <td>CD4</td>
     <td>Copy-initialization in member initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1634">
-    <td><a href="http://wg21.link/cwg1634">1634</a></td>
+    <td><a href="https://wg21.link/cwg1634">1634</a></td>
     <td>drafting</td>
     <td>Temporary storage duration</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1635">
-    <td><a href="http://wg21.link/cwg1635">1635</a></td>
+    <td><a href="https://wg21.link/cwg1635">1635</a></td>
     <td>drafting</td>
     <td>How similar are template default arguments to function default arguments?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1636">
-    <td><a href="http://wg21.link/cwg1636">1636</a></td>
+    <td><a href="https://wg21.link/cwg1636">1636</a></td>
     <td>DRWP</td>
     <td>Bits required for negative enumerator values</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1637">
-    <td><a href="http://wg21.link/cwg1637">1637</a></td>
+    <td><a href="https://wg21.link/cwg1637">1637</a></td>
     <td>NAD</td>
     <td>Recursion in <TT>constexpr</TT> template default constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1638">
-    <td><a href="http://wg21.link/cwg1638">1638</a></td>
+    <td><a href="https://wg21.link/cwg1638">1638</a></td>
     <td>CD4</td>
     <td>Declaring an explicit specialization of a scoped enumeration</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1639">
-    <td><a href="http://wg21.link/cwg1639">1639</a></td>
+    <td><a href="https://wg21.link/cwg1639">1639</a></td>
     <td>CD4</td>
     <td><I>exception-specification</I>s and pointer/pointer-to-member expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1640">
-    <td><a href="http://wg21.link/cwg1640">1640</a></td>
+    <td><a href="https://wg21.link/cwg1640">1640</a></td>
     <td>drafting</td>
     <td>Array of abstract instance of class template</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1641">
-    <td><a href="http://wg21.link/cwg1641">1641</a></td>
+    <td><a href="https://wg21.link/cwg1641">1641</a></td>
     <td>NAD</td>
     <td>Assignment in member initializer</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1642">
-    <td><a href="http://wg21.link/cwg1642">1642</a></td>
+    <td><a href="https://wg21.link/cwg1642">1642</a></td>
     <td>open</td>
     <td>Missing requirements for prvalue operands</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1643">
-    <td><a href="http://wg21.link/cwg1643">1643</a></td>
+    <td><a href="https://wg21.link/cwg1643">1643</a></td>
     <td>extension</td>
     <td>Default arguments for template parameter packs</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="1644">
-    <td><a href="http://wg21.link/cwg1644">1644</a></td>
+    <td><a href="https://wg21.link/cwg1644">1644</a></td>
     <td>open</td>
     <td>Equivalent <I>exception-specification</I>s in function template declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1645">
-    <td><a href="http://wg21.link/cwg1645">1645</a></td>
+    <td><a href="https://wg21.link/cwg1645">1645</a></td>
     <td>CD4</td>
     <td>Identical inheriting constructors via default arguments</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr class="open" id="1646">
-    <td><a href="http://wg21.link/cwg1646">1646</a></td>
+    <td><a href="https://wg21.link/cwg1646">1646</a></td>
     <td>drafting</td>
     <td><I>decltype-specifier</I>s, abstract classes, and deduction failure</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1647">
-    <td><a href="http://wg21.link/cwg1647">1647</a></td>
+    <td><a href="https://wg21.link/cwg1647">1647</a></td>
     <td>drafting</td>
     <td>Type agreement of non-type template arguments in partial specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1648">
-    <td><a href="http://wg21.link/cwg1648">1648</a></td>
+    <td><a href="https://wg21.link/cwg1648">1648</a></td>
     <td>C++14</td>
     <td><TT>thread_local</TT> vs block extern declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1649">
-    <td><a href="http://wg21.link/cwg1649">1649</a></td>
+    <td><a href="https://wg21.link/cwg1649">1649</a></td>
     <td>C++14</td>
     <td>Error in the syntax of <I>mem-initializer-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1650">
-    <td><a href="http://wg21.link/cwg1650">1650</a></td>
+    <td><a href="https://wg21.link/cwg1650">1650</a></td>
     <td>NAD</td>
     <td>Class prvalues in reference initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1651">
-    <td><a href="http://wg21.link/cwg1651">1651</a></td>
+    <td><a href="https://wg21.link/cwg1651">1651</a></td>
     <td>NAD</td>
     <td>Lifetime extension of temporary via reference to subobject</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1652">
-    <td><a href="http://wg21.link/cwg1652">1652</a></td>
+    <td><a href="https://wg21.link/cwg1652">1652</a></td>
     <td>CD4</td>
     <td>Object addresses in <TT>constexpr</TT> expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1653">
-    <td><a href="http://wg21.link/cwg1653">1653</a></td>
+    <td><a href="https://wg21.link/cwg1653">1653</a></td>
     <td>CD4</td>
     <td>Removing deprecated increment of <TT>bool</TT></td>
     <td class="full" align="center">Clang 4 (C++17 onwards)</td>
   </tr>
   <tr id="1654">
-    <td><a href="http://wg21.link/cwg1654">1654</a></td>
+    <td><a href="https://wg21.link/cwg1654">1654</a></td>
     <td>dup</td>
     <td>Literal types and <TT>constexpr</TT> defaulted constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1655">
-    <td><a href="http://wg21.link/cwg1655">1655</a></td>
+    <td><a href="https://wg21.link/cwg1655">1655</a></td>
     <td>drafting</td>
     <td>Line endings in raw string literals</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1656">
-    <td><a href="http://wg21.link/cwg1656">1656</a></td>
+    <td><a href="https://wg21.link/cwg1656">1656</a></td>
     <td>drafting</td>
     <td>Encoding of numerically-escaped characters</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1657">
-    <td><a href="http://wg21.link/cwg1657">1657</a></td>
+    <td><a href="https://wg21.link/cwg1657">1657</a></td>
     <td>CD4</td>
     <td>Attributes for namespaces and enumerators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1658">
-    <td><a href="http://wg21.link/cwg1658">1658</a></td>
+    <td><a href="https://wg21.link/cwg1658">1658</a></td>
     <td>C++14</td>
     <td>Deleted default constructor for abstract class via destructor</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr class="open" id="1659">
-    <td><a href="http://wg21.link/cwg1659">1659</a></td>
+    <td><a href="https://wg21.link/cwg1659">1659</a></td>
     <td>open</td>
     <td>Initialization order of thread_local template static data members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1660">
-    <td><a href="http://wg21.link/cwg1660">1660</a></td>
+    <td><a href="https://wg21.link/cwg1660">1660</a></td>
     <td>C++14</td>
     <td><I>member-declaration</I> requirements and unnamed bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1661">
-    <td><a href="http://wg21.link/cwg1661">1661</a></td>
+    <td><a href="https://wg21.link/cwg1661">1661</a></td>
     <td>NAD</td>
     <td>Preservation of infinite loops</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1662">
-    <td><a href="http://wg21.link/cwg1662">1662</a></td>
+    <td><a href="https://wg21.link/cwg1662">1662</a></td>
     <td>C++14</td>
     <td>Capturing function parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1663">
-    <td><a href="http://wg21.link/cwg1663">1663</a></td>
+    <td><a href="https://wg21.link/cwg1663">1663</a></td>
     <td>NAD</td>
     <td>Capturing an empty pack expansion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1664">
-    <td><a href="http://wg21.link/cwg1664">1664</a></td>
+    <td><a href="https://wg21.link/cwg1664">1664</a></td>
     <td>C++14</td>
     <td>Argument-dependent lookup of lambdas used in default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1665">
-    <td><a href="http://wg21.link/cwg1665">1665</a></td>
+    <td><a href="https://wg21.link/cwg1665">1665</a></td>
     <td>drafting</td>
     <td>Declaration matching in explicit instantiations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1666">
-    <td><a href="http://wg21.link/cwg1666">1666</a></td>
+    <td><a href="https://wg21.link/cwg1666">1666</a></td>
     <td>C++14</td>
     <td>Address constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1667">
-    <td><a href="http://wg21.link/cwg1667">1667</a></td>
+    <td><a href="https://wg21.link/cwg1667">1667</a></td>
     <td>NAD</td>
     <td>Function exiting via exception called by destructor during unwinding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1668">
-    <td><a href="http://wg21.link/cwg1668">1668</a></td>
+    <td><a href="https://wg21.link/cwg1668">1668</a></td>
     <td>drafting</td>
     <td>Parameter type determination still not clear enough</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1669">
-    <td><a href="http://wg21.link/cwg1669">1669</a></td>
+    <td><a href="https://wg21.link/cwg1669">1669</a></td>
     <td>C++14</td>
     <td><TT>auto</TT> return type for <TT>main</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1670">
-    <td><a href="http://wg21.link/cwg1670">1670</a></td>
+    <td><a href="https://wg21.link/cwg1670">1670</a></td>
     <td>drafting</td>
     <td><TT>auto</TT> as <I>conversion-type-id</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1671">
-    <td><a href="http://wg21.link/cwg1671">1671</a></td>
+    <td><a href="https://wg21.link/cwg1671">1671</a></td>
     <td>NAD</td>
     <td>Unclear rules for deduction with cv-qualification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1672">
-    <td><a href="http://wg21.link/cwg1672">1672</a></td>
+    <td><a href="https://wg21.link/cwg1672">1672</a></td>
     <td>CD4</td>
     <td>Layout compatibility with multiple empty bases</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="1673">
-    <td><a href="http://wg21.link/cwg1673">1673</a></td>
+    <td><a href="https://wg21.link/cwg1673">1673</a></td>
     <td>C++14</td>
     <td>Clarifying overload resolution for the second step of copy-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1674">
-    <td><a href="http://wg21.link/cwg1674">1674</a></td>
+    <td><a href="https://wg21.link/cwg1674">1674</a></td>
     <td>C++14</td>
     <td>Return type deduction for address of function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1675">
-    <td><a href="http://wg21.link/cwg1675">1675</a></td>
+    <td><a href="https://wg21.link/cwg1675">1675</a></td>
     <td>NAD</td>
     <td>Size limit for automatic array object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1676">
-    <td><a href="http://wg21.link/cwg1676">1676</a></td>
+    <td><a href="https://wg21.link/cwg1676">1676</a></td>
     <td>drafting</td>
     <td><TT>auto</TT> return type for allocation and deallocation functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1677">
-    <td><a href="http://wg21.link/cwg1677">1677</a></td>
+    <td><a href="https://wg21.link/cwg1677">1677</a></td>
     <td>C++17</td>
     <td>Constant initialization via aggregate initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1678">
-    <td><a href="http://wg21.link/cwg1678">1678</a></td>
+    <td><a href="https://wg21.link/cwg1678">1678</a></td>
     <td>NAD</td>
     <td>Naming the type of an array of runtime bound</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1679">
-    <td><a href="http://wg21.link/cwg1679">1679</a></td>
+    <td><a href="https://wg21.link/cwg1679">1679</a></td>
     <td>NAD</td>
     <td>Range-based <TT>for</TT> and array of runtime bound</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1680">
-    <td><a href="http://wg21.link/cwg1680">1680</a></td>
+    <td><a href="https://wg21.link/cwg1680">1680</a></td>
     <td>drafting</td>
     <td>Including <TT>&lt;initializer_list&gt;</TT> for range-based <TT>for</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1681">
-    <td><a href="http://wg21.link/cwg1681">1681</a></td>
+    <td><a href="https://wg21.link/cwg1681">1681</a></td>
     <td>C++14</td>
     <td><I>init-capture</I>s and nested lambdas</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1682">
-    <td><a href="http://wg21.link/cwg1682">1682</a></td>
+    <td><a href="https://wg21.link/cwg1682">1682</a></td>
     <td>open</td>
     <td>Overly-restrictive rules on function templates as allocation functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1683">
-    <td><a href="http://wg21.link/cwg1683">1683</a></td>
+    <td><a href="https://wg21.link/cwg1683">1683</a></td>
     <td>CD4</td>
     <td>Incorrect example after <TT>constexpr</TT> changes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1684">
-    <td><a href="http://wg21.link/cwg1684">1684</a></td>
+    <td><a href="https://wg21.link/cwg1684">1684</a></td>
     <td>C++14</td>
     <td>Static <TT>constexpr</TT> member functions for non-literal classes</td>
     <td class="full" align="center">Clang 3.6</td>
   </tr>
   <tr id="1685">
-    <td><a href="http://wg21.link/cwg1685">1685</a></td>
+    <td><a href="https://wg21.link/cwg1685">1685</a></td>
     <td>NAD</td>
     <td>Value category of <TT>noexcept</TT> expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1686">
-    <td><a href="http://wg21.link/cwg1686">1686</a></td>
+    <td><a href="https://wg21.link/cwg1686">1686</a></td>
     <td>CD4</td>
     <td>Which variables are &#8220;explicitly declared <TT>const</TT>?&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1687">
-    <td><a href="http://wg21.link/cwg1687">1687</a></td>
+    <td><a href="https://wg21.link/cwg1687">1687</a></td>
     <td>C++14</td>
     <td>Conversions of operands of built-in operators</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="1688">
-    <td><a href="http://wg21.link/cwg1688">1688</a></td>
+    <td><a href="https://wg21.link/cwg1688">1688</a></td>
     <td>NAD</td>
     <td>Volatile <TT>constexpr</TT> variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1689">
-    <td><a href="http://wg21.link/cwg1689">1689</a></td>
+    <td><a href="https://wg21.link/cwg1689">1689</a></td>
     <td>C++14</td>
     <td>Syntactic nonterminal for operand of <TT>alignas</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1690">
-    <td><a href="http://wg21.link/cwg1690">1690</a></td>
+    <td><a href="https://wg21.link/cwg1690">1690</a></td>
     <td>C++14</td>
     <td>Associated namespace for local type</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="1691">
-    <td><a href="http://wg21.link/cwg1691">1691</a></td>
+    <td><a href="https://wg21.link/cwg1691">1691</a></td>
     <td>C++14</td>
     <td>Argument-dependent lookup and opaque enumerations</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="1692">
-    <td><a href="http://wg21.link/cwg1692">1692</a></td>
+    <td><a href="https://wg21.link/cwg1692">1692</a></td>
     <td>C++14</td>
     <td>Associated namespaces of doubly-nested classes</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="1693">
-    <td><a href="http://wg21.link/cwg1693">1693</a></td>
+    <td><a href="https://wg21.link/cwg1693">1693</a></td>
     <td>C++14</td>
     <td>Superfluous semicolons in class definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1694">
-    <td><a href="http://wg21.link/cwg1694">1694</a></td>
+    <td><a href="https://wg21.link/cwg1694">1694</a></td>
     <td>CD4</td>
     <td>Restriction on reference to temporary as a constant expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1695">
-    <td><a href="http://wg21.link/cwg1695">1695</a></td>
+    <td><a href="https://wg21.link/cwg1695">1695</a></td>
     <td>NAD</td>
     <td>Lifetime extension via <I>init-capture</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1696">
-    <td><a href="http://wg21.link/cwg1696">1696</a></td>
+    <td><a href="https://wg21.link/cwg1696">1696</a></td>
     <td>CD4</td>
     <td>Temporary lifetime and non-static data member initializers</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="1697">
-    <td><a href="http://wg21.link/cwg1697">1697</a></td>
+    <td><a href="https://wg21.link/cwg1697">1697</a></td>
     <td>CD4</td>
     <td>Lifetime extension and copy elision</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1698">
-    <td><a href="http://wg21.link/cwg1698">1698</a></td>
+    <td><a href="https://wg21.link/cwg1698">1698</a></td>
     <td>open</td>
     <td>Files ending in <TT>\</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1699">
-    <td><a href="http://wg21.link/cwg1699">1699</a></td>
+    <td><a href="https://wg21.link/cwg1699">1699</a></td>
     <td>drafting</td>
     <td>Does befriending a class befriend its friends?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1700">
-    <td><a href="http://wg21.link/cwg1700">1700</a></td>
+    <td><a href="https://wg21.link/cwg1700">1700</a></td>
     <td>NAD</td>
     <td>Does the special rvalue-reference deduction apply to alias templates?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1701">
-    <td><a href="http://wg21.link/cwg1701">1701</a></td>
+    <td><a href="https://wg21.link/cwg1701">1701</a></td>
     <td>drafting</td>
     <td>Array vs sequence in object representation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1702">
-    <td><a href="http://wg21.link/cwg1702">1702</a></td>
+    <td><a href="https://wg21.link/cwg1702">1702</a></td>
     <td>drafting</td>
     <td>Rephrasing the definition of &#8220;anonymous union&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1703">
-    <td><a href="http://wg21.link/cwg1703">1703</a></td>
+    <td><a href="https://wg21.link/cwg1703">1703</a></td>
     <td>NAD</td>
     <td>Language linkage of names of functions with internal linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1704">
-    <td><a href="http://wg21.link/cwg1704">1704</a></td>
+    <td><a href="https://wg21.link/cwg1704">1704</a></td>
     <td>DRWP</td>
     <td>Type checking in explicit instantiation of variable templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1705">
-    <td><a href="http://wg21.link/cwg1705">1705</a></td>
+    <td><a href="https://wg21.link/cwg1705">1705</a></td>
     <td>CD4</td>
     <td>Unclear specification of &#8220;more specialized&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1706">
-    <td><a href="http://wg21.link/cwg1706">1706</a></td>
+    <td><a href="https://wg21.link/cwg1706">1706</a></td>
     <td>drafting</td>
     <td><TT>alignas</TT> pack expansion syntax</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1707">
-    <td><a href="http://wg21.link/cwg1707">1707</a></td>
+    <td><a href="https://wg21.link/cwg1707">1707</a></td>
     <td>C++14</td>
     <td><TT>template</TT> in <I>elaborated-type-specifier</I> without <I>nested-name-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1708">
-    <td><a href="http://wg21.link/cwg1708">1708</a></td>
+    <td><a href="https://wg21.link/cwg1708">1708</a></td>
     <td>CD4</td>
     <td>overly-strict requirements for names with C language linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1709">
-    <td><a href="http://wg21.link/cwg1709">1709</a></td>
+    <td><a href="https://wg21.link/cwg1709">1709</a></td>
     <td>drafting</td>
     <td>Stringizing raw string literals containing newline</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1710">
-    <td><a href="http://wg21.link/cwg1710">1710</a></td>
+    <td><a href="https://wg21.link/cwg1710">1710</a></td>
     <td>C++17</td>
     <td>Missing <TT>template</TT> keyword in <I>class-or-decltype</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1711">
-    <td><a href="http://wg21.link/cwg1711">1711</a></td>
+    <td><a href="https://wg21.link/cwg1711">1711</a></td>
     <td>drafting</td>
     <td>Missing specification of variable template partial specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1712">
-    <td><a href="http://wg21.link/cwg1712">1712</a></td>
+    <td><a href="https://wg21.link/cwg1712">1712</a></td>
     <td>CD4</td>
     <td><TT>constexpr</TT> variable template declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1713">
-    <td><a href="http://wg21.link/cwg1713">1713</a></td>
+    <td><a href="https://wg21.link/cwg1713">1713</a></td>
     <td>drafting</td>
     <td>Linkage of variable template specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1714">
-    <td><a href="http://wg21.link/cwg1714">1714</a></td>
+    <td><a href="https://wg21.link/cwg1714">1714</a></td>
     <td>NAD</td>
     <td>odr-use of <TT>this</TT> from a local class</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1715">
-    <td><a href="http://wg21.link/cwg1715">1715</a></td>
+    <td><a href="https://wg21.link/cwg1715">1715</a></td>
     <td>CD4</td>
     <td>Access and inherited constructor templates</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1716">
-    <td><a href="http://wg21.link/cwg1716">1716</a></td>
+    <td><a href="https://wg21.link/cwg1716">1716</a></td>
     <td>C++14</td>
     <td>When are default arguments evaluated?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1717">
-    <td><a href="http://wg21.link/cwg1717">1717</a></td>
+    <td><a href="https://wg21.link/cwg1717">1717</a></td>
     <td>C++14</td>
     <td>Missing specification of type of binary literal</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1718">
-    <td><a href="http://wg21.link/cwg1718">1718</a></td>
+    <td><a href="https://wg21.link/cwg1718">1718</a></td>
     <td>drafting</td>
     <td>Macro invocation spanning end-of-file</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1719">
-    <td><a href="http://wg21.link/cwg1719">1719</a></td>
+    <td><a href="https://wg21.link/cwg1719">1719</a></td>
     <td>CD4</td>
     <td>Layout compatibility and cv-qualification revisited</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1720">
-    <td><a href="http://wg21.link/cwg1720">1720</a></td>
+    <td><a href="https://wg21.link/cwg1720">1720</a></td>
     <td>NAD</td>
     <td>Macro invocation in <TT>#include</TT> directive</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1721">
-    <td><a href="http://wg21.link/cwg1721">1721</a></td>
+    <td><a href="https://wg21.link/cwg1721">1721</a></td>
     <td>drafting</td>
     <td>Diagnosing ODR violations for static data members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1722">
-    <td><a href="http://wg21.link/cwg1722">1722</a></td>
+    <td><a href="https://wg21.link/cwg1722">1722</a></td>
     <td>CD4</td>
     <td>Should lambda to function pointer conversion function be <TT>noexcept</TT>?</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr class="open" id="1723">
-    <td><a href="http://wg21.link/cwg1723">1723</a></td>
+    <td><a href="https://wg21.link/cwg1723">1723</a></td>
     <td>drafting</td>
     <td>Multicharacter user-defined character literals</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1724">
-    <td><a href="http://wg21.link/cwg1724">1724</a></td>
+    <td><a href="https://wg21.link/cwg1724">1724</a></td>
     <td>drafting</td>
     <td>Unclear rules for deduction failure</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1725">
-    <td><a href="http://wg21.link/cwg1725">1725</a></td>
+    <td><a href="https://wg21.link/cwg1725">1725</a></td>
     <td>NAD</td>
     <td>Trailing return type with nested function declarator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1726">
-    <td><a href="http://wg21.link/cwg1726">1726</a></td>
+    <td><a href="https://wg21.link/cwg1726">1726</a></td>
     <td>drafting</td>
     <td>Declarator operators and conversion function</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1727">
-    <td><a href="http://wg21.link/cwg1727">1727</a></td>
+    <td><a href="https://wg21.link/cwg1727">1727</a></td>
     <td>NAD</td>
     <td>Type of a specialization of a variable template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1728">
-    <td><a href="http://wg21.link/cwg1728">1728</a></td>
+    <td><a href="https://wg21.link/cwg1728">1728</a></td>
     <td>DRWP</td>
     <td>Type of an explicit instantiation of a variable template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1729">
-    <td><a href="http://wg21.link/cwg1729">1729</a></td>
+    <td><a href="https://wg21.link/cwg1729">1729</a></td>
     <td>drafting</td>
     <td>Matching declarations and definitions of variable templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1730">
-    <td><a href="http://wg21.link/cwg1730">1730</a></td>
+    <td><a href="https://wg21.link/cwg1730">1730</a></td>
     <td>drafting</td>
     <td>Can a variable template have an unnamed type?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1731">
-    <td><a href="http://wg21.link/cwg1731">1731</a></td>
+    <td><a href="https://wg21.link/cwg1731">1731</a></td>
     <td>NAD</td>
     <td><TT>is_trivially_</TT><I>X</I> and definitions of special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1732">
-    <td><a href="http://wg21.link/cwg1732">1732</a></td>
+    <td><a href="https://wg21.link/cwg1732">1732</a></td>
     <td>C++14</td>
     <td>Defining types in <I>condition</I>s and range-based <TT>for</TT> statements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1733">
-    <td><a href="http://wg21.link/cwg1733">1733</a></td>
+    <td><a href="https://wg21.link/cwg1733">1733</a></td>
     <td>drafting</td>
     <td>Return type and value for <TT>operator=</TT> with <I>ref-qualifier</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1734">
-    <td><a href="http://wg21.link/cwg1734">1734</a></td>
+    <td><a href="https://wg21.link/cwg1734">1734</a></td>
     <td>CD4</td>
     <td>Nontrivial deleted copy functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1735">
-    <td><a href="http://wg21.link/cwg1735">1735</a></td>
+    <td><a href="https://wg21.link/cwg1735">1735</a></td>
     <td>drafting</td>
     <td>Out-of-range literals in <I>user-defined-literal</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1736">
-    <td><a href="http://wg21.link/cwg1736">1736</a></td>
+    <td><a href="https://wg21.link/cwg1736">1736</a></td>
     <td>CD4</td>
     <td>Inheriting constructor templates in a local class</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1737">
-    <td><a href="http://wg21.link/cwg1737">1737</a></td>
+    <td><a href="https://wg21.link/cwg1737">1737</a></td>
     <td>C++14</td>
     <td>Type dependence of call to a member of the current instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1738">
-    <td><a href="http://wg21.link/cwg1738">1738</a></td>
+    <td><a href="https://wg21.link/cwg1738">1738</a></td>
     <td>C++14</td>
     <td>Explicit instantiation/specialization of inheriting constructor templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1739">
-    <td><a href="http://wg21.link/cwg1739">1739</a></td>
+    <td><a href="https://wg21.link/cwg1739">1739</a></td>
     <td>C++14</td>
     <td>Conversion of floating point to enumeration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1740">
-    <td><a href="http://wg21.link/cwg1740">1740</a></td>
+    <td><a href="https://wg21.link/cwg1740">1740</a></td>
     <td>C++14</td>
     <td>Disambiguation of <TT>noexcept</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1741">
-    <td><a href="http://wg21.link/cwg1741">1741</a></td>
+    <td><a href="https://wg21.link/cwg1741">1741</a></td>
     <td>C++14</td>
     <td>odr-use of class object in lvalue-to-rvalue conversion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1742">
-    <td><a href="http://wg21.link/cwg1742">1742</a></td>
+    <td><a href="https://wg21.link/cwg1742">1742</a></td>
     <td>open</td>
     <td><I>using-declaration</I>s and scoped enumerators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1743">
-    <td><a href="http://wg21.link/cwg1743">1743</a></td>
+    <td><a href="https://wg21.link/cwg1743">1743</a></td>
     <td>NAD</td>
     <td><I>init-capture</I>s in nested lambdas</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1744">
-    <td><a href="http://wg21.link/cwg1744">1744</a></td>
+    <td><a href="https://wg21.link/cwg1744">1744</a></td>
     <td>CD4</td>
     <td>Unordered initialization for variable template specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1745">
-    <td><a href="http://wg21.link/cwg1745">1745</a></td>
+    <td><a href="https://wg21.link/cwg1745">1745</a></td>
     <td>NAD</td>
     <td><TT>thread_local constexpr</TT> variable</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1746">
-    <td><a href="http://wg21.link/cwg1746">1746</a></td>
+    <td><a href="https://wg21.link/cwg1746">1746</a></td>
     <td>C++14</td>
     <td>Are volatile scalar types trivially copyable?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1747">
-    <td><a href="http://wg21.link/cwg1747">1747</a></td>
+    <td><a href="https://wg21.link/cwg1747">1747</a></td>
     <td>C++14</td>
     <td>Constant initialization of reference to function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1748">
-    <td><a href="http://wg21.link/cwg1748">1748</a></td>
+    <td><a href="https://wg21.link/cwg1748">1748</a></td>
     <td>CD4</td>
     <td>Placement new with a null pointer</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="1749">
-    <td><a href="http://wg21.link/cwg1749">1749</a></td>
+    <td><a href="https://wg21.link/cwg1749">1749</a></td>
     <td>NAD</td>
     <td>Confusing definition for constant initializer</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1750">
-    <td><a href="http://wg21.link/cwg1750">1750</a></td>
+    <td><a href="https://wg21.link/cwg1750">1750</a></td>
     <td>CD4</td>
     <td>&#8220;Argument&#8221; vs &#8220;parameter&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1751">
-    <td><a href="http://wg21.link/cwg1751">1751</a></td>
+    <td><a href="https://wg21.link/cwg1751">1751</a></td>
     <td>CD4</td>
     <td>Non-trivial operations vs non-trivial initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1752">
-    <td><a href="http://wg21.link/cwg1752">1752</a></td>
+    <td><a href="https://wg21.link/cwg1752">1752</a></td>
     <td>CD4</td>
     <td>Right-recursion in <I>mem-initializer-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1753">
-    <td><a href="http://wg21.link/cwg1753">1753</a></td>
+    <td><a href="https://wg21.link/cwg1753">1753</a></td>
     <td>CD4</td>
     <td><I>decltype-specifier</I> in <I>nested-name-specifier</I> of destructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1754">
-    <td><a href="http://wg21.link/cwg1754">1754</a></td>
+    <td><a href="https://wg21.link/cwg1754">1754</a></td>
     <td>NAD</td>
     <td>Declaration of partial specialization of static data member template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1755">
-    <td><a href="http://wg21.link/cwg1755">1755</a></td>
+    <td><a href="https://wg21.link/cwg1755">1755</a></td>
     <td>drafting</td>
     <td>Out-of-class partial specializations of member templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1756">
-    <td><a href="http://wg21.link/cwg1756">1756</a></td>
+    <td><a href="https://wg21.link/cwg1756">1756</a></td>
     <td>CD4</td>
     <td>Direct-list-initialization of a non-class object</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="1757">
-    <td><a href="http://wg21.link/cwg1757">1757</a></td>
+    <td><a href="https://wg21.link/cwg1757">1757</a></td>
     <td>CD4</td>
     <td>Const integral subobjects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1758">
-    <td><a href="http://wg21.link/cwg1758">1758</a></td>
+    <td><a href="https://wg21.link/cwg1758">1758</a></td>
     <td>CD4</td>
     <td>Explicit conversion in copy/move list initialization</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="1759">
-    <td><a href="http://wg21.link/cwg1759">1759</a></td>
+    <td><a href="https://wg21.link/cwg1759">1759</a></td>
     <td>C++14</td>
     <td>UTF-8 code units in plain <TT>char</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1760">
-    <td><a href="http://wg21.link/cwg1760">1760</a></td>
+    <td><a href="https://wg21.link/cwg1760">1760</a></td>
     <td>C++14</td>
     <td>Access of member corresponding to <I>init-capture</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1761">
-    <td><a href="http://wg21.link/cwg1761">1761</a></td>
+    <td><a href="https://wg21.link/cwg1761">1761</a></td>
     <td>NAD</td>
     <td>Runtime check on size of automatic array</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1762">
-    <td><a href="http://wg21.link/cwg1762">1762</a></td>
+    <td><a href="https://wg21.link/cwg1762">1762</a></td>
     <td>C++14</td>
     <td>Reserved identifier used in <I>literal-operator-id</I> example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1763">
-    <td><a href="http://wg21.link/cwg1763">1763</a></td>
+    <td><a href="https://wg21.link/cwg1763">1763</a></td>
     <td>open</td>
     <td>Length mismatch in template type deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1764">
-    <td><a href="http://wg21.link/cwg1764">1764</a></td>
+    <td><a href="https://wg21.link/cwg1764">1764</a></td>
     <td>C++14</td>
     <td>Hiding of function from using-declaration by signature</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1765">
-    <td><a href="http://wg21.link/cwg1765">1765</a></td>
+    <td><a href="https://wg21.link/cwg1765">1765</a></td>
     <td>C++14</td>
     <td>Overflow of enumeration used as enumerator value</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1766">
-    <td><a href="http://wg21.link/cwg1766">1766</a></td>
+    <td><a href="https://wg21.link/cwg1766">1766</a></td>
     <td>CD4</td>
     <td>Values outside the range of the values of an enumeration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1767">
-    <td><a href="http://wg21.link/cwg1767">1767</a></td>
+    <td><a href="https://wg21.link/cwg1767">1767</a></td>
     <td>C++14</td>
     <td>Scoped enumeration in a <TT>switch</TT> statement</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1768">
-    <td><a href="http://wg21.link/cwg1768">1768</a></td>
+    <td><a href="https://wg21.link/cwg1768">1768</a></td>
     <td>NAD</td>
     <td>Zero-element array of runtime bound</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1769">
-    <td><a href="http://wg21.link/cwg1769">1769</a></td>
+    <td><a href="https://wg21.link/cwg1769">1769</a></td>
     <td>C++14</td>
     <td>Catching a base class of the exception object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1770">
-    <td><a href="http://wg21.link/cwg1770">1770</a></td>
+    <td><a href="https://wg21.link/cwg1770">1770</a></td>
     <td>C++14</td>
     <td>Type matching of non-type template parameters and arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1771">
-    <td><a href="http://wg21.link/cwg1771">1771</a></td>
+    <td><a href="https://wg21.link/cwg1771">1771</a></td>
     <td>open</td>
     <td>Restricted lookup in <I>nested-name-specifier</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1772">
-    <td><a href="http://wg21.link/cwg1772">1772</a></td>
+    <td><a href="https://wg21.link/cwg1772">1772</a></td>
     <td>C++14</td>
     <td><TT>__func__</TT> in a lambda body</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1773">
-    <td><a href="http://wg21.link/cwg1773">1773</a></td>
+    <td><a href="https://wg21.link/cwg1773">1773</a></td>
     <td>C++14</td>
     <td>Out-of-lifetime lvalue-to-rvalue conversion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1774">
-    <td><a href="http://wg21.link/cwg1774">1774</a></td>
+    <td><a href="https://wg21.link/cwg1774">1774</a></td>
     <td>CD4</td>
     <td>Discrepancy between subobject destruction and stack unwinding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1775">
-    <td><a href="http://wg21.link/cwg1775">1775</a></td>
+    <td><a href="https://wg21.link/cwg1775">1775</a></td>
     <td>C++14</td>
     <td>Undefined behavior of line splice in raw string literal</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1776">
-    <td><a href="http://wg21.link/cwg1776">1776</a></td>
+    <td><a href="https://wg21.link/cwg1776">1776</a></td>
     <td>CD4</td>
     <td>Replacement of class objects containing reference members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1777">
-    <td><a href="http://wg21.link/cwg1777">1777</a></td>
+    <td><a href="https://wg21.link/cwg1777">1777</a></td>
     <td>CD4</td>
     <td>Empty pack expansion in <I>dynamic-exception-specification</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1778">
-    <td><a href="http://wg21.link/cwg1778">1778</a></td>
+    <td><a href="https://wg21.link/cwg1778">1778</a></td>
     <td>C++14</td>
     <td><I>exception-specification</I> in explicitly-defaulted functions</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="1779">
-    <td><a href="http://wg21.link/cwg1779">1779</a></td>
+    <td><a href="https://wg21.link/cwg1779">1779</a></td>
     <td>CD4</td>
     <td>Type dependency of <TT>__func__</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1780">
-    <td><a href="http://wg21.link/cwg1780">1780</a></td>
+    <td><a href="https://wg21.link/cwg1780">1780</a></td>
     <td>CD4</td>
     <td>Explicit instantiation/specialization of generic lambda <TT>operator()</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1781">
-    <td><a href="http://wg21.link/cwg1781">1781</a></td>
+    <td><a href="https://wg21.link/cwg1781">1781</a></td>
     <td>DRWP</td>
     <td>Converting from <TT>nullptr_t</TT> to <TT>bool</TT> in overload resolution</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1782">
-    <td><a href="http://wg21.link/cwg1782">1782</a></td>
+    <td><a href="https://wg21.link/cwg1782">1782</a></td>
     <td>CD4</td>
     <td>Form of initialization for <TT>nullptr_t</TT> to <TT>bool</TT> conversion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1783">
-    <td><a href="http://wg21.link/cwg1783">1783</a></td>
+    <td><a href="https://wg21.link/cwg1783">1783</a></td>
     <td>NAD</td>
     <td>Why are virtual destructors non-trivial?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1784">
-    <td><a href="http://wg21.link/cwg1784">1784</a></td>
+    <td><a href="https://wg21.link/cwg1784">1784</a></td>
     <td>C++17</td>
     <td>Concurrent execution during static local initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1785">
-    <td><a href="http://wg21.link/cwg1785">1785</a></td>
+    <td><a href="https://wg21.link/cwg1785">1785</a></td>
     <td>NAD</td>
     <td>Conflicting diagnostic requirements for template definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1786">
-    <td><a href="http://wg21.link/cwg1786">1786</a></td>
+    <td><a href="https://wg21.link/cwg1786">1786</a></td>
     <td>C++14</td>
     <td>Effect of merging allocations on memory leakage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1787">
-    <td><a href="http://wg21.link/cwg1787">1787</a></td>
+    <td><a href="https://wg21.link/cwg1787">1787</a></td>
     <td>C++14</td>
     <td>Uninitialized <TT>unsigned char</TT> values</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1788">
-    <td><a href="http://wg21.link/cwg1788">1788</a></td>
+    <td><a href="https://wg21.link/cwg1788">1788</a></td>
     <td>CD4</td>
     <td>Sized deallocation of array of non-class type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1789">
-    <td><a href="http://wg21.link/cwg1789">1789</a></td>
+    <td><a href="https://wg21.link/cwg1789">1789</a></td>
     <td>drafting</td>
     <td>Array reference vs array decay in overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1790">
-    <td><a href="http://wg21.link/cwg1790">1790</a></td>
+    <td><a href="https://wg21.link/cwg1790">1790</a></td>
     <td>extension</td>
     <td>Ellipsis following function parameter pack</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1791">
-    <td><a href="http://wg21.link/cwg1791">1791</a></td>
+    <td><a href="https://wg21.link/cwg1791">1791</a></td>
     <td>CD4</td>
     <td>Incorrect restrictions on <I>cv-qualifier-seq</I> and <I>ref-qualifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1792">
-    <td><a href="http://wg21.link/cwg1792">1792</a></td>
+    <td><a href="https://wg21.link/cwg1792">1792</a></td>
     <td>NAD</td>
     <td>Incorrect example of explicit specialization of member enumeration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1793">
-    <td><a href="http://wg21.link/cwg1793">1793</a></td>
+    <td><a href="https://wg21.link/cwg1793">1793</a></td>
     <td>CD4</td>
     <td><TT>thread_local</TT> in explicit specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1794">
-    <td><a href="http://wg21.link/cwg1794">1794</a></td>
+    <td><a href="https://wg21.link/cwg1794">1794</a></td>
     <td>C++17</td>
     <td><TT>template</TT> keyword and alias templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1795">
-    <td><a href="http://wg21.link/cwg1795">1795</a></td>
+    <td><a href="https://wg21.link/cwg1795">1795</a></td>
     <td>CD4</td>
     <td>Disambiguating <I>original-namespace-definition</I> and <I>extension-namespace-definition</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1796">
-    <td><a href="http://wg21.link/cwg1796">1796</a></td>
+    <td><a href="https://wg21.link/cwg1796">1796</a></td>
     <td>CD4</td>
     <td>Is all-bits-zero for null characters a meaningful requirement?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1797">
-    <td><a href="http://wg21.link/cwg1797">1797</a></td>
+    <td><a href="https://wg21.link/cwg1797">1797</a></td>
     <td>CD4</td>
     <td>Are all bit patterns of <TT>unsigned char</TT> distinct numbers?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1798">
-    <td><a href="http://wg21.link/cwg1798">1798</a></td>
+    <td><a href="https://wg21.link/cwg1798">1798</a></td>
     <td>NAD</td>
     <td><I>exception-specification</I>s of template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1799">
-    <td><a href="http://wg21.link/cwg1799">1799</a></td>
+    <td><a href="https://wg21.link/cwg1799">1799</a></td>
     <td>CD4</td>
     <td><TT>mutable</TT> and non-explicit const qualification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1800">
-    <td><a href="http://wg21.link/cwg1800">1800</a></td>
+    <td><a href="https://wg21.link/cwg1800">1800</a></td>
     <td>CD4</td>
     <td>Pointer to member of nested anonymous union</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1801">
-    <td><a href="http://wg21.link/cwg1801">1801</a></td>
+    <td><a href="https://wg21.link/cwg1801">1801</a></td>
     <td>drafting</td>
     <td>Kind of expression referring to member of anonymous union</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1802">
-    <td><a href="http://wg21.link/cwg1802">1802</a></td>
+    <td><a href="https://wg21.link/cwg1802">1802</a></td>
     <td>CD4</td>
     <td><TT>char16_t</TT> string literals and surrogate pairs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1803">
-    <td><a href="http://wg21.link/cwg1803">1803</a></td>
+    <td><a href="https://wg21.link/cwg1803">1803</a></td>
     <td>drafting</td>
     <td><I>opaque-enum-declaration</I> as <I>member-declaration</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1804">
-    <td><a href="http://wg21.link/cwg1804">1804</a></td>
+    <td><a href="https://wg21.link/cwg1804">1804</a></td>
     <td>CD4</td>
     <td>Partial specialization and friendship</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1805">
-    <td><a href="http://wg21.link/cwg1805">1805</a></td>
+    <td><a href="https://wg21.link/cwg1805">1805</a></td>
     <td>CD4</td>
     <td>Conversions of array operands in <I>conditional-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1806">
-    <td><a href="http://wg21.link/cwg1806">1806</a></td>
+    <td><a href="https://wg21.link/cwg1806">1806</a></td>
     <td>CD4</td>
     <td>Virtual bases and move-assignment</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1807">
-    <td><a href="http://wg21.link/cwg1807">1807</a></td>
+    <td><a href="https://wg21.link/cwg1807">1807</a></td>
     <td>CD4</td>
     <td>Order of destruction of array elements after an exception</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1808">
-    <td><a href="http://wg21.link/cwg1808">1808</a></td>
+    <td><a href="https://wg21.link/cwg1808">1808</a></td>
     <td>drafting</td>
     <td>Constructor templates vs default constructors</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1809">
-    <td><a href="http://wg21.link/cwg1809">1809</a></td>
+    <td><a href="https://wg21.link/cwg1809">1809</a></td>
     <td>CD4</td>
     <td>Narrowing and template argument deduction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1810">
-    <td><a href="http://wg21.link/cwg1810">1810</a></td>
+    <td><a href="https://wg21.link/cwg1810">1810</a></td>
     <td>CD4</td>
     <td>Invalid <I>ud-suffix</I>es</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1811">
-    <td><a href="http://wg21.link/cwg1811">1811</a></td>
+    <td><a href="https://wg21.link/cwg1811">1811</a></td>
     <td>CD4</td>
     <td>Lookup of deallocation function in a virtual destructor definition</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1812">
-    <td><a href="http://wg21.link/cwg1812">1812</a></td>
+    <td><a href="https://wg21.link/cwg1812">1812</a></td>
     <td>C++17</td>
     <td>Omission of <TT>template</TT> in a <I>typename-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1813">
-    <td><a href="http://wg21.link/cwg1813">1813</a></td>
+    <td><a href="https://wg21.link/cwg1813">1813</a></td>
     <td>CD4</td>
     <td>Direct vs indirect bases in standard-layout classes</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="1814">
-    <td><a href="http://wg21.link/cwg1814">1814</a></td>
+    <td><a href="https://wg21.link/cwg1814">1814</a></td>
     <td>CD4</td>
     <td>Default arguments in <I>lambda-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1815">
-    <td><a href="http://wg21.link/cwg1815">1815</a></td>
+    <td><a href="https://wg21.link/cwg1815">1815</a></td>
     <td>CD4</td>
     <td>Lifetime extension in aggregate initialization</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="1816">
-    <td><a href="http://wg21.link/cwg1816">1816</a></td>
+    <td><a href="https://wg21.link/cwg1816">1816</a></td>
     <td>CD4</td>
     <td>Unclear specification of bit-field values</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1817">
-    <td><a href="http://wg21.link/cwg1817">1817</a></td>
+    <td><a href="https://wg21.link/cwg1817">1817</a></td>
     <td>drafting</td>
     <td>Linkage specifications and nested scopes</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1818">
-    <td><a href="http://wg21.link/cwg1818">1818</a></td>
+    <td><a href="https://wg21.link/cwg1818">1818</a></td>
     <td>open</td>
     <td>Visibility and inherited language linkage</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1819">
-    <td><a href="http://wg21.link/cwg1819">1819</a></td>
+    <td><a href="https://wg21.link/cwg1819">1819</a></td>
     <td>CD4</td>
     <td>Acceptable scopes for definition of partial specialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1820">
-    <td><a href="http://wg21.link/cwg1820">1820</a></td>
+    <td><a href="https://wg21.link/cwg1820">1820</a></td>
     <td>open</td>
     <td>Qualified typedef names</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1821">
-    <td><a href="http://wg21.link/cwg1821">1821</a></td>
+    <td><a href="https://wg21.link/cwg1821">1821</a></td>
     <td>open</td>
     <td>Qualified redeclarations in a class <I>member-specification</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1822">
-    <td><a href="http://wg21.link/cwg1822">1822</a></td>
+    <td><a href="https://wg21.link/cwg1822">1822</a></td>
     <td>open</td>
     <td>Lookup of parameter names in <I>lambda-expression</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1823">
-    <td><a href="http://wg21.link/cwg1823">1823</a></td>
+    <td><a href="https://wg21.link/cwg1823">1823</a></td>
     <td>CD4</td>
     <td>String literal uniqueness in inline functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1824">
-    <td><a href="http://wg21.link/cwg1824">1824</a></td>
+    <td><a href="https://wg21.link/cwg1824">1824</a></td>
     <td>CD4</td>
     <td>Completeness of return type vs point of instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1825">
-    <td><a href="http://wg21.link/cwg1825">1825</a></td>
+    <td><a href="https://wg21.link/cwg1825">1825</a></td>
     <td>C++17</td>
     <td>Partial ordering between variadic and non-variadic function templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1826">
-    <td><a href="http://wg21.link/cwg1826">1826</a></td>
+    <td><a href="https://wg21.link/cwg1826">1826</a></td>
     <td>NAD</td>
     <td><TT>const</TT> floating-point in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1827">
-    <td><a href="http://wg21.link/cwg1827">1827</a></td>
+    <td><a href="https://wg21.link/cwg1827">1827</a></td>
     <td>drafting</td>
     <td>Reference binding with ambiguous conversions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1828">
-    <td><a href="http://wg21.link/cwg1828">1828</a></td>
+    <td><a href="https://wg21.link/cwg1828">1828</a></td>
     <td>drafting</td>
     <td><I>nested-name-specifier</I> ambiguity</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1829">
-    <td><a href="http://wg21.link/cwg1829">1829</a></td>
+    <td><a href="https://wg21.link/cwg1829">1829</a></td>
     <td>open</td>
     <td>Dependent unnamed types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1830">
-    <td><a href="http://wg21.link/cwg1830">1830</a></td>
+    <td><a href="https://wg21.link/cwg1830">1830</a></td>
     <td>CD4</td>
     <td>Repeated specifiers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1831">
-    <td><a href="http://wg21.link/cwg1831">1831</a></td>
+    <td><a href="https://wg21.link/cwg1831">1831</a></td>
     <td>NAD</td>
     <td>Explicitly vs implicitly deleted move constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1832">
-    <td><a href="http://wg21.link/cwg1832">1832</a></td>
+    <td><a href="https://wg21.link/cwg1832">1832</a></td>
     <td>CD4</td>
     <td>Casting to incomplete enumeration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1833">
-    <td><a href="http://wg21.link/cwg1833">1833</a></td>
+    <td><a href="https://wg21.link/cwg1833">1833</a></td>
     <td>NAD</td>
     <td><TT>friend</TT> declarations naming implicitly-declared member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1834">
-    <td><a href="http://wg21.link/cwg1834">1834</a></td>
+    <td><a href="https://wg21.link/cwg1834">1834</a></td>
     <td>CD4</td>
     <td>Constant initialization binding a reference to an xvalue</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1835">
-    <td><a href="http://wg21.link/cwg1835">1835</a></td>
+    <td><a href="https://wg21.link/cwg1835">1835</a></td>
     <td>drafting</td>
     <td>Dependent member lookup before <TT>&lt;</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1836">
-    <td><a href="http://wg21.link/cwg1836">1836</a></td>
+    <td><a href="https://wg21.link/cwg1836">1836</a></td>
     <td>DRWP</td>
     <td>Use of class type being defined in <I>trailing-return-type</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1837">
-    <td><a href="http://wg21.link/cwg1837">1837</a></td>
+    <td><a href="https://wg21.link/cwg1837">1837</a></td>
     <td>drafting</td>
     <td>Use of <TT>this</TT> in <TT>friend</TT> and local class declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1838">
-    <td><a href="http://wg21.link/cwg1838">1838</a></td>
+    <td><a href="https://wg21.link/cwg1838">1838</a></td>
     <td>CD4</td>
     <td>Definition via <I>unqualified-id</I> and <I>using-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1839">
-    <td><a href="http://wg21.link/cwg1839">1839</a></td>
+    <td><a href="https://wg21.link/cwg1839">1839</a></td>
     <td>review</td>
     <td>Lookup of block-scope <TT>extern</TT> declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1840">
-    <td><a href="http://wg21.link/cwg1840">1840</a></td>
+    <td><a href="https://wg21.link/cwg1840">1840</a></td>
     <td>drafting</td>
     <td>Non-deleted explicit specialization of deleted function template</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1841">
-    <td><a href="http://wg21.link/cwg1841">1841</a></td>
+    <td><a href="https://wg21.link/cwg1841">1841</a></td>
     <td>drafting</td>
     <td><TT>&lt;</TT> following template injected-class-name</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1842">
-    <td><a href="http://wg21.link/cwg1842">1842</a></td>
+    <td><a href="https://wg21.link/cwg1842">1842</a></td>
     <td>concurrency</td>
     <td>Unevaluated operands and &#8220;carries a dependency&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1843">
-    <td><a href="http://wg21.link/cwg1843">1843</a></td>
+    <td><a href="https://wg21.link/cwg1843">1843</a></td>
     <td>CD4</td>
     <td>Bit-field in conditional operator with <TT>throw</TT> operand</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1844">
-    <td><a href="http://wg21.link/cwg1844">1844</a></td>
+    <td><a href="https://wg21.link/cwg1844">1844</a></td>
     <td>drafting</td>
     <td>Defining &#8220;immediate context&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1845">
-    <td><a href="http://wg21.link/cwg1845">1845</a></td>
+    <td><a href="https://wg21.link/cwg1845">1845</a></td>
     <td>drafting</td>
     <td>Point of instantiation of a variable template specialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1846">
-    <td><a href="http://wg21.link/cwg1846">1846</a></td>
+    <td><a href="https://wg21.link/cwg1846">1846</a></td>
     <td>CD4</td>
     <td>Declaring explicitly-defaulted implicitly-deleted functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1847">
-    <td><a href="http://wg21.link/cwg1847">1847</a></td>
+    <td><a href="https://wg21.link/cwg1847">1847</a></td>
     <td>CD4</td>
     <td>Clarifying compatibility during partial ordering</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1848">
-    <td><a href="http://wg21.link/cwg1848">1848</a></td>
+    <td><a href="https://wg21.link/cwg1848">1848</a></td>
     <td>CD4</td>
     <td>Parenthesized constructor and destructor declarators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1849">
-    <td><a href="http://wg21.link/cwg1849">1849</a></td>
+    <td><a href="https://wg21.link/cwg1849">1849</a></td>
     <td>drafting</td>
     <td>Variable templates and the ODR</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1850">
-    <td><a href="http://wg21.link/cwg1850">1850</a></td>
+    <td><a href="https://wg21.link/cwg1850">1850</a></td>
     <td>CD4</td>
     <td>Differences between definition context and point of instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1851">
-    <td><a href="http://wg21.link/cwg1851">1851</a></td>
+    <td><a href="https://wg21.link/cwg1851">1851</a></td>
     <td>CD4</td>
     <td><TT>decltype(auto)</TT> in <I>new-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1852">
-    <td><a href="http://wg21.link/cwg1852">1852</a></td>
+    <td><a href="https://wg21.link/cwg1852">1852</a></td>
     <td>CD4</td>
     <td>Wording issues regarding <TT>decltype(auto)</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1853">
-    <td><a href="http://wg21.link/cwg1853">1853</a></td>
+    <td><a href="https://wg21.link/cwg1853">1853</a></td>
     <td>drafting</td>
     <td>Defining &#8220;allocated storage&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1854">
-    <td><a href="http://wg21.link/cwg1854">1854</a></td>
+    <td><a href="https://wg21.link/cwg1854">1854</a></td>
     <td>drafting</td>
     <td>Disallowing use of implicitly-deleted functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1855">
-    <td><a href="http://wg21.link/cwg1855">1855</a></td>
+    <td><a href="https://wg21.link/cwg1855">1855</a></td>
     <td>dup</td>
     <td>Out-of-lifetime access to nonstatic data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1856">
-    <td><a href="http://wg21.link/cwg1856">1856</a></td>
+    <td><a href="https://wg21.link/cwg1856">1856</a></td>
     <td>open</td>
     <td>Indirect nested classes of class templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1857">
-    <td><a href="http://wg21.link/cwg1857">1857</a></td>
+    <td><a href="https://wg21.link/cwg1857">1857</a></td>
     <td>drafting</td>
     <td>Additional questions about bits</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1858">
-    <td><a href="http://wg21.link/cwg1858">1858</a></td>
+    <td><a href="https://wg21.link/cwg1858">1858</a></td>
     <td>CD4</td>
     <td>Comparing pointers to union members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1859">
-    <td><a href="http://wg21.link/cwg1859">1859</a></td>
+    <td><a href="https://wg21.link/cwg1859">1859</a></td>
     <td>NAD</td>
     <td>UTF-16 in <TT>char16_t</TT> string literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1860">
-    <td><a href="http://wg21.link/cwg1860">1860</a></td>
+    <td><a href="https://wg21.link/cwg1860">1860</a></td>
     <td>C++17</td>
     <td>What is a &#8220;direct member?&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1861">
-    <td><a href="http://wg21.link/cwg1861">1861</a></td>
+    <td><a href="https://wg21.link/cwg1861">1861</a></td>
     <td>CD4</td>
     <td>Values of a bit-field</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1862">
-    <td><a href="http://wg21.link/cwg1862">1862</a></td>
+    <td><a href="https://wg21.link/cwg1862">1862</a></td>
     <td>DRWP</td>
     <td>Determining &#8220;corresponding members&#8221; for friendship</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1863">
-    <td><a href="http://wg21.link/cwg1863">1863</a></td>
+    <td><a href="https://wg21.link/cwg1863">1863</a></td>
     <td>CD4</td>
     <td>Requirements on thrown object type to support <TT>std::current_exception()</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1864">
-    <td><a href="http://wg21.link/cwg1864">1864</a></td>
+    <td><a href="https://wg21.link/cwg1864">1864</a></td>
     <td>extension</td>
     <td>List-initialization of array objects</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1865">
-    <td><a href="http://wg21.link/cwg1865">1865</a></td>
+    <td><a href="https://wg21.link/cwg1865">1865</a></td>
     <td>CD4</td>
     <td>Pointer arithmetic and multi-level qualification conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1866">
-    <td><a href="http://wg21.link/cwg1866">1866</a></td>
+    <td><a href="https://wg21.link/cwg1866">1866</a></td>
     <td>CD4</td>
     <td>Initializing variant members with non-trivial destructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1867">
-    <td><a href="http://wg21.link/cwg1867">1867</a></td>
+    <td><a href="https://wg21.link/cwg1867">1867</a></td>
     <td>NAD</td>
     <td>Function/expression ambiguity with qualified parameter name</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1868">
-    <td><a href="http://wg21.link/cwg1868">1868</a></td>
+    <td><a href="https://wg21.link/cwg1868">1868</a></td>
     <td>drafting</td>
     <td>Meaning of &#8220;placeholder type&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1869">
-    <td><a href="http://wg21.link/cwg1869">1869</a></td>
+    <td><a href="https://wg21.link/cwg1869">1869</a></td>
     <td>NAD</td>
     <td><TT>thread_local</TT> vs <I>linkage-specification</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1870">
-    <td><a href="http://wg21.link/cwg1870">1870</a></td>
+    <td><a href="https://wg21.link/cwg1870">1870</a></td>
     <td>CD4</td>
     <td>Contradictory wording about definitions vs explicit specialization/instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1871">
-    <td><a href="http://wg21.link/cwg1871">1871</a></td>
+    <td><a href="https://wg21.link/cwg1871">1871</a></td>
     <td>extension</td>
     <td>Non-identifier characters in <I>ud-suffix</I></td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1872">
-    <td><a href="http://wg21.link/cwg1872">1872</a></td>
+    <td><a href="https://wg21.link/cwg1872">1872</a></td>
     <td>CD4</td>
     <td>Instantiations of <TT>constexpr</TT> templates that cannot appear in constant expressions</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="1873">
-    <td><a href="http://wg21.link/cwg1873">1873</a></td>
+    <td><a href="https://wg21.link/cwg1873">1873</a></td>
     <td>CD4</td>
     <td>Protected member access from derived class friends</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1874">
-    <td><a href="http://wg21.link/cwg1874">1874</a></td>
+    <td><a href="https://wg21.link/cwg1874">1874</a></td>
     <td>CD4</td>
     <td>Type vs non-type template parameters with <TT>class</TT> keyword</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1875">
-    <td><a href="http://wg21.link/cwg1875">1875</a></td>
+    <td><a href="https://wg21.link/cwg1875">1875</a></td>
     <td>CD4</td>
     <td>Reordering declarations in class scope</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1876">
-    <td><a href="http://wg21.link/cwg1876">1876</a></td>
+    <td><a href="https://wg21.link/cwg1876">1876</a></td>
     <td>extension</td>
     <td>Preventing explicit specialization</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1877">
-    <td><a href="http://wg21.link/cwg1877">1877</a></td>
+    <td><a href="https://wg21.link/cwg1877">1877</a></td>
     <td>CD4</td>
     <td>Return type deduction from <TT>return</TT> with no operand</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1878">
-    <td><a href="http://wg21.link/cwg1878">1878</a></td>
+    <td><a href="https://wg21.link/cwg1878">1878</a></td>
     <td>CD4</td>
     <td><TT>operator auto</TT> template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1879">
-    <td><a href="http://wg21.link/cwg1879">1879</a></td>
+    <td><a href="https://wg21.link/cwg1879">1879</a></td>
     <td>NAD</td>
     <td>Inadequate definition of alignment requirement</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1880">
-    <td><a href="http://wg21.link/cwg1880">1880</a></td>
+    <td><a href="https://wg21.link/cwg1880">1880</a></td>
     <td>drafting</td>
     <td>When are parameter objects destroyed?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1881">
-    <td><a href="http://wg21.link/cwg1881">1881</a></td>
+    <td><a href="https://wg21.link/cwg1881">1881</a></td>
     <td>CD4</td>
     <td>Standard-layout classes and unnamed bit-fields</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="1882">
-    <td><a href="http://wg21.link/cwg1882">1882</a></td>
+    <td><a href="https://wg21.link/cwg1882">1882</a></td>
     <td>CD4</td>
     <td>Reserved names without library use</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1883">
-    <td><a href="http://wg21.link/cwg1883">1883</a></td>
+    <td><a href="https://wg21.link/cwg1883">1883</a></td>
     <td>drafting</td>
     <td>Protected access to constructors in <I>mem-initializer</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1884">
-    <td><a href="http://wg21.link/cwg1884">1884</a></td>
+    <td><a href="https://wg21.link/cwg1884">1884</a></td>
     <td>drafting</td>
     <td>Unclear requirements for same-named external-linkage entities</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1885">
-    <td><a href="http://wg21.link/cwg1885">1885</a></td>
+    <td><a href="https://wg21.link/cwg1885">1885</a></td>
     <td>CD4</td>
     <td>Return value of a function is underspecified</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1886">
-    <td><a href="http://wg21.link/cwg1886">1886</a></td>
+    <td><a href="https://wg21.link/cwg1886">1886</a></td>
     <td>CD4</td>
     <td>Language linkage for <TT>main()</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1887">
-    <td><a href="http://wg21.link/cwg1887">1887</a></td>
+    <td><a href="https://wg21.link/cwg1887">1887</a></td>
     <td>CD4</td>
     <td>Problems with <TT>::</TT> as <I>nested-name-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1888">
-    <td><a href="http://wg21.link/cwg1888">1888</a></td>
+    <td><a href="https://wg21.link/cwg1888">1888</a></td>
     <td>CD4</td>
     <td>Implicitly-declared default constructors and <TT>explicit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1889">
-    <td><a href="http://wg21.link/cwg1889">1889</a></td>
+    <td><a href="https://wg21.link/cwg1889">1889</a></td>
     <td>drafting</td>
     <td>Unclear effect of <TT>#pragma</TT> on conformance</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1890">
-    <td><a href="http://wg21.link/cwg1890">1890</a></td>
+    <td><a href="https://wg21.link/cwg1890">1890</a></td>
     <td>drafting</td>
     <td>Member type depending on definition of member function</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1891">
-    <td><a href="http://wg21.link/cwg1891">1891</a></td>
+    <td><a href="https://wg21.link/cwg1891">1891</a></td>
     <td>CD4</td>
     <td>Move constructor/assignment for closure class</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="1892">
-    <td><a href="http://wg21.link/cwg1892">1892</a></td>
+    <td><a href="https://wg21.link/cwg1892">1892</a></td>
     <td>CD4</td>
     <td>Use of <TT>auto</TT> in function type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1893">
-    <td><a href="http://wg21.link/cwg1893">1893</a></td>
+    <td><a href="https://wg21.link/cwg1893">1893</a></td>
     <td>DRWP</td>
     <td>Function-style cast with <I>braced-init-list</I>s and empty pack expansions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1894">
-    <td><a href="http://wg21.link/cwg1894">1894</a></td>
+    <td><a href="https://wg21.link/cwg1894">1894</a></td>
     <td>open</td>
     <td><I>typedef-name</I>s and <I>using-declaration</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1895">
-    <td><a href="http://wg21.link/cwg1895">1895</a></td>
+    <td><a href="https://wg21.link/cwg1895">1895</a></td>
     <td>CD4</td>
     <td>Deleted conversions in conditional operator operands</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1896">
-    <td><a href="http://wg21.link/cwg1896">1896</a></td>
+    <td><a href="https://wg21.link/cwg1896">1896</a></td>
     <td>drafting</td>
     <td>Repeated alias templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1897">
-    <td><a href="http://wg21.link/cwg1897">1897</a></td>
+    <td><a href="https://wg21.link/cwg1897">1897</a></td>
     <td>drafting</td>
     <td>ODR vs alternative tokens</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1898">
-    <td><a href="http://wg21.link/cwg1898">1898</a></td>
+    <td><a href="https://wg21.link/cwg1898">1898</a></td>
     <td>drafting</td>
     <td>Use of &#8220;equivalent&#8221; in overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1899">
-    <td><a href="http://wg21.link/cwg1899">1899</a></td>
+    <td><a href="https://wg21.link/cwg1899">1899</a></td>
     <td>CD4</td>
     <td>Value-dependent constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1900">
-    <td><a href="http://wg21.link/cwg1900">1900</a></td>
+    <td><a href="https://wg21.link/cwg1900">1900</a></td>
     <td>drafting</td>
     <td>Do <TT>friend</TT> declarations count as &#8220;previous declarations&#8221;?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1901">
-    <td><a href="http://wg21.link/cwg1901">1901</a></td>
+    <td><a href="https://wg21.link/cwg1901">1901</a></td>
     <td>drafting</td>
     <td><I>punctuator</I> referenced but not defined</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1902">
-    <td><a href="http://wg21.link/cwg1902">1902</a></td>
+    <td><a href="https://wg21.link/cwg1902">1902</a></td>
     <td>CD4</td>
     <td>What makes a conversion &#8220;otherwise ill-formed&#8221;?</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="1903">
-    <td><a href="http://wg21.link/cwg1903">1903</a></td>
+    <td><a href="https://wg21.link/cwg1903">1903</a></td>
     <td>CD4</td>
     <td>What declarations are introduced by a non-member <I>using-declaration</I>?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1904">
-    <td><a href="http://wg21.link/cwg1904">1904</a></td>
+    <td><a href="https://wg21.link/cwg1904">1904</a></td>
     <td>NAD</td>
     <td>Default template arguments for members of class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1905">
-    <td><a href="http://wg21.link/cwg1905">1905</a></td>
+    <td><a href="https://wg21.link/cwg1905">1905</a></td>
     <td>MAD</td>
     <td>Dependent types and injected-class-names</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1906">
-    <td><a href="http://wg21.link/cwg1906">1906</a></td>
+    <td><a href="https://wg21.link/cwg1906">1906</a></td>
     <td>NAD</td>
     <td>Name lookup in member <TT>friend</TT> declaration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1907">
-    <td><a href="http://wg21.link/cwg1907">1907</a></td>
+    <td><a href="https://wg21.link/cwg1907">1907</a></td>
     <td>drafting</td>
     <td><I>using-declaration</I>s and default arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1908">
-    <td><a href="http://wg21.link/cwg1908">1908</a></td>
+    <td><a href="https://wg21.link/cwg1908">1908</a></td>
     <td>drafting</td>
     <td>Dual destructor lookup and <I>template-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1909">
-    <td><a href="http://wg21.link/cwg1909">1909</a></td>
+    <td><a href="https://wg21.link/cwg1909">1909</a></td>
     <td>CD4</td>
     <td>Member class template with the same name as the class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1910">
-    <td><a href="http://wg21.link/cwg1910">1910</a></td>
+    <td><a href="https://wg21.link/cwg1910">1910</a></td>
     <td>DRWP</td>
     <td>&#8220;Shall&#8221; requirement applied to runtime behavior</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1911">
-    <td><a href="http://wg21.link/cwg1911">1911</a></td>
+    <td><a href="https://wg21.link/cwg1911">1911</a></td>
     <td>CD4</td>
     <td><TT>constexpr</TT> constructor with non-literal base class</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1912">
-    <td><a href="http://wg21.link/cwg1912">1912</a></td>
+    <td><a href="https://wg21.link/cwg1912">1912</a></td>
     <td>extension</td>
     <td><I>exception-specification</I> of defaulted function</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1913">
-    <td><a href="http://wg21.link/cwg1913">1913</a></td>
+    <td><a href="https://wg21.link/cwg1913">1913</a></td>
     <td>DRWP</td>
     <td><TT>decltype((x))</TT> in <I>lambda-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1914">
-    <td><a href="http://wg21.link/cwg1914">1914</a></td>
+    <td><a href="https://wg21.link/cwg1914">1914</a></td>
     <td>extension</td>
     <td>Duplicate standard attributes</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="1915">
-    <td><a href="http://wg21.link/cwg1915">1915</a></td>
+    <td><a href="https://wg21.link/cwg1915">1915</a></td>
     <td>extension</td>
     <td>Potentially-invoked destructors in non-throwing constructors</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1916">
-    <td><a href="http://wg21.link/cwg1916">1916</a></td>
+    <td><a href="https://wg21.link/cwg1916">1916</a></td>
     <td>CD4</td>
     <td>&#8220;Same cv-unqualified type&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1917">
-    <td><a href="http://wg21.link/cwg1917">1917</a></td>
+    <td><a href="https://wg21.link/cwg1917">1917</a></td>
     <td>drafting</td>
     <td>decltype-qualified enumeration names</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1918">
-    <td><a href="http://wg21.link/cwg1918">1918</a></td>
+    <td><a href="https://wg21.link/cwg1918">1918</a></td>
     <td>open</td>
     <td><TT>friend</TT> templates with dependent scopes</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1919">
-    <td><a href="http://wg21.link/cwg1919">1919</a></td>
+    <td><a href="https://wg21.link/cwg1919">1919</a></td>
     <td>open</td>
     <td>Overload resolution for <TT>!</TT> with explicit conversion operator</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1920">
-    <td><a href="http://wg21.link/cwg1920">1920</a></td>
+    <td><a href="https://wg21.link/cwg1920">1920</a></td>
     <td>CD4</td>
     <td>Qualification mismatch in <I>pseudo-destructor-name</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1921">
-    <td><a href="http://wg21.link/cwg1921">1921</a></td>
+    <td><a href="https://wg21.link/cwg1921">1921</a></td>
     <td>NAD</td>
     <td><TT>constexpr</TT> constructors and point of initialization of <TT>const</TT> variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1922">
-    <td><a href="http://wg21.link/cwg1922">1922</a></td>
+    <td><a href="https://wg21.link/cwg1922">1922</a></td>
     <td>CD4</td>
     <td>Injected class template names and default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1923">
-    <td><a href="http://wg21.link/cwg1923">1923</a></td>
+    <td><a href="https://wg21.link/cwg1923">1923</a></td>
     <td>extension</td>
     <td>Lvalues of type <TT>void</TT></td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="1924">
-    <td><a href="http://wg21.link/cwg1924">1924</a></td>
+    <td><a href="https://wg21.link/cwg1924">1924</a></td>
     <td>review</td>
     <td>Definition of &#8220;literal&#8221; and kinds of literals</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1925">
-    <td><a href="http://wg21.link/cwg1925">1925</a></td>
+    <td><a href="https://wg21.link/cwg1925">1925</a></td>
     <td>CD4</td>
     <td>Bit-field prvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1926">
-    <td><a href="http://wg21.link/cwg1926">1926</a></td>
+    <td><a href="https://wg21.link/cwg1926">1926</a></td>
     <td>CD4</td>
     <td>Potential results of subscript operator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1927">
-    <td><a href="http://wg21.link/cwg1927">1927</a></td>
+    <td><a href="https://wg21.link/cwg1927">1927</a></td>
     <td>dup</td>
     <td>Lifetime of temporaries in <I>init-capture</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1928">
-    <td><a href="http://wg21.link/cwg1928">1928</a></td>
+    <td><a href="https://wg21.link/cwg1928">1928</a></td>
     <td>NAD</td>
     <td>Triviality of deleted special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1929">
-    <td><a href="http://wg21.link/cwg1929">1929</a></td>
+    <td><a href="https://wg21.link/cwg1929">1929</a></td>
     <td>CD4</td>
     <td><TT>template</TT> keyword following namespace <I>nested-name-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1930">
-    <td><a href="http://wg21.link/cwg1930">1930</a></td>
+    <td><a href="https://wg21.link/cwg1930">1930</a></td>
     <td>CD4</td>
     <td><I>init-declarator-list</I> vs <I>member-declarator-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1931">
-    <td><a href="http://wg21.link/cwg1931">1931</a></td>
+    <td><a href="https://wg21.link/cwg1931">1931</a></td>
     <td>extension</td>
     <td>Default-constructible and copy-assignable closure types</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1932">
-    <td><a href="http://wg21.link/cwg1932">1932</a></td>
+    <td><a href="https://wg21.link/cwg1932">1932</a></td>
     <td>CD4</td>
     <td>Bit-field results of conditional operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1933">
-    <td><a href="http://wg21.link/cwg1933">1933</a></td>
+    <td><a href="https://wg21.link/cwg1933">1933</a></td>
     <td>NAD</td>
     <td>Implementation limit for <I>initializer-list</I> elements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1934">
-    <td><a href="http://wg21.link/cwg1934">1934</a></td>
+    <td><a href="https://wg21.link/cwg1934">1934</a></td>
     <td>extension</td>
     <td>Relaxing <I>exception-specification</I> compatibility requirements</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="1935">
-    <td><a href="http://wg21.link/cwg1935">1935</a></td>
+    <td><a href="https://wg21.link/cwg1935">1935</a></td>
     <td>drafting</td>
     <td>Reuse of placement arguments in deallocation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1936">
-    <td><a href="http://wg21.link/cwg1936">1936</a></td>
+    <td><a href="https://wg21.link/cwg1936">1936</a></td>
     <td>drafting</td>
     <td>Dependent <I>qualified-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1937">
-    <td><a href="http://wg21.link/cwg1937">1937</a></td>
+    <td><a href="https://wg21.link/cwg1937">1937</a></td>
     <td>DR</td>
     <td>Incomplete specification of function pointer from lambda</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1938">
-    <td><a href="http://wg21.link/cwg1938">1938</a></td>
+    <td><a href="https://wg21.link/cwg1938">1938</a></td>
     <td>DR</td>
     <td>Should hosted/freestanding be implementation-defined?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1939">
-    <td><a href="http://wg21.link/cwg1939">1939</a></td>
+    <td><a href="https://wg21.link/cwg1939">1939</a></td>
     <td>drafting</td>
     <td>Argument conversions to nondeduced parameter types revisited</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1940">
-    <td><a href="http://wg21.link/cwg1940">1940</a></td>
+    <td><a href="https://wg21.link/cwg1940">1940</a></td>
     <td>CD4</td>
     <td><TT>static_assert</TT> in anonymous unions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1941">
-    <td><a href="http://wg21.link/cwg1941">1941</a></td>
+    <td><a href="https://wg21.link/cwg1941">1941</a></td>
     <td>CD4</td>
     <td>SFINAE and inherited constructor default arguments</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1942">
-    <td><a href="http://wg21.link/cwg1942">1942</a></td>
+    <td><a href="https://wg21.link/cwg1942">1942</a></td>
     <td>CD4</td>
     <td>Incorrect reference to <I>trailing-return-type</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1943">
-    <td><a href="http://wg21.link/cwg1943">1943</a></td>
+    <td><a href="https://wg21.link/cwg1943">1943</a></td>
     <td>open</td>
     <td>Unspecified meaning of &#8220;bit&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1944">
-    <td><a href="http://wg21.link/cwg1944">1944</a></td>
+    <td><a href="https://wg21.link/cwg1944">1944</a></td>
     <td>open</td>
     <td>New C incompatibilities</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1945">
-    <td><a href="http://wg21.link/cwg1945">1945</a></td>
+    <td><a href="https://wg21.link/cwg1945">1945</a></td>
     <td>open</td>
     <td>Friend declarations naming members of class templates in non-templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1946">
-    <td><a href="http://wg21.link/cwg1946">1946</a></td>
+    <td><a href="https://wg21.link/cwg1946">1946</a></td>
     <td>CD4</td>
     <td><I>exception-specification</I>s vs pointer dereference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1947">
-    <td><a href="http://wg21.link/cwg1947">1947</a></td>
+    <td><a href="https://wg21.link/cwg1947">1947</a></td>
     <td>NAD</td>
     <td>Digit separators following non-octal prefix</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1948">
-    <td><a href="http://wg21.link/cwg1948">1948</a></td>
+    <td><a href="https://wg21.link/cwg1948">1948</a></td>
     <td>NAD</td>
     <td><I>exception-specification</I> of replacement global <TT>new</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="1949">
-    <td><a href="http://wg21.link/cwg1949">1949</a></td>
+    <td><a href="https://wg21.link/cwg1949">1949</a></td>
     <td>CD4</td>
     <td>&#8220;sequenced after&#8221; instead of &#8220;sequenced before&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1950">
-    <td><a href="http://wg21.link/cwg1950">1950</a></td>
+    <td><a href="https://wg21.link/cwg1950">1950</a></td>
     <td>NAD</td>
     <td>Restructuring description of ranks of conversion sequences</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1951">
-    <td><a href="http://wg21.link/cwg1951">1951</a></td>
+    <td><a href="https://wg21.link/cwg1951">1951</a></td>
     <td>CD4</td>
     <td>Cv-qualification and literal types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1952">
-    <td><a href="http://wg21.link/cwg1952">1952</a></td>
+    <td><a href="https://wg21.link/cwg1952">1952</a></td>
     <td>CD4</td>
     <td>Constant expressions and library undefined behavior</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1953">
-    <td><a href="http://wg21.link/cwg1953">1953</a></td>
+    <td><a href="https://wg21.link/cwg1953">1953</a></td>
     <td>open</td>
     <td>Data races and common initial sequence</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1954">
-    <td><a href="http://wg21.link/cwg1954">1954</a></td>
+    <td><a href="https://wg21.link/cwg1954">1954</a></td>
     <td>open</td>
     <td><TT>typeid</TT> null dereference check in subexpressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1955">
-    <td><a href="http://wg21.link/cwg1955">1955</a></td>
+    <td><a href="https://wg21.link/cwg1955">1955</a></td>
     <td>CD4</td>
     <td><TT>#elif</TT> with invalid controlling expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1956">
-    <td><a href="http://wg21.link/cwg1956">1956</a></td>
+    <td><a href="https://wg21.link/cwg1956">1956</a></td>
     <td>CD4</td>
     <td>Reuse of storage of automatic variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1957">
-    <td><a href="http://wg21.link/cwg1957">1957</a></td>
+    <td><a href="https://wg21.link/cwg1957">1957</a></td>
     <td>extension</td>
     <td><TT>decltype(auto)</TT> with direct-list-initialization</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1958">
-    <td><a href="http://wg21.link/cwg1958">1958</a></td>
+    <td><a href="https://wg21.link/cwg1958">1958</a></td>
     <td>CD4</td>
     <td><TT>decltype(auto)</TT> with parenthesized initializer</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1959">
-    <td><a href="http://wg21.link/cwg1959">1959</a></td>
+    <td><a href="https://wg21.link/cwg1959">1959</a></td>
     <td>CD4</td>
     <td>Inadvertently inherited copy constructor</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1960">
-    <td><a href="http://wg21.link/cwg1960">1960</a></td>
+    <td><a href="https://wg21.link/cwg1960">1960</a></td>
     <td>NAD</td>
     <td>Visibility of entity named in class-scope <I>using-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1961">
-    <td><a href="http://wg21.link/cwg1961">1961</a></td>
+    <td><a href="https://wg21.link/cwg1961">1961</a></td>
     <td>C++17</td>
     <td>Potentially-concurrent actions within a signal handler</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1962">
-    <td><a href="http://wg21.link/cwg1962">1962</a></td>
+    <td><a href="https://wg21.link/cwg1962">1962</a></td>
     <td>extension</td>
     <td>Type of <TT>__func__</TT></td>
     <td align="center">Extension</td>
   </tr>
   <tr id="1963">
-    <td><a href="http://wg21.link/cwg1963">1963</a></td>
+    <td><a href="https://wg21.link/cwg1963">1963</a></td>
     <td>CD4</td>
     <td>Implementation-defined identifier characters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1964">
-    <td><a href="http://wg21.link/cwg1964">1964</a></td>
+    <td><a href="https://wg21.link/cwg1964">1964</a></td>
     <td>NAD</td>
     <td><I>opaque-enum-declaration</I> in <I>alias-declaration</I>?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1965">
-    <td><a href="http://wg21.link/cwg1965">1965</a></td>
+    <td><a href="https://wg21.link/cwg1965">1965</a></td>
     <td>drafting</td>
     <td>Explicit casts to reference types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1966">
-    <td><a href="http://wg21.link/cwg1966">1966</a></td>
+    <td><a href="https://wg21.link/cwg1966">1966</a></td>
     <td>CD4</td>
     <td>Colon following enumeration <I>elaborated-type-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1967">
-    <td><a href="http://wg21.link/cwg1967">1967</a></td>
+    <td><a href="https://wg21.link/cwg1967">1967</a></td>
     <td>CD4</td>
     <td>Temporary lifetime and move-elision</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1968">
-    <td><a href="http://wg21.link/cwg1968">1968</a></td>
+    <td><a href="https://wg21.link/cwg1968">1968</a></td>
     <td>NAD</td>
     <td>Address of <TT>typeid</TT> in constant expressions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="1969">
-    <td><a href="http://wg21.link/cwg1969">1969</a></td>
+    <td><a href="https://wg21.link/cwg1969">1969</a></td>
     <td>open</td>
     <td>Missing exclusion of <TT>~S</TT> as an ordinary function name</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1970">
-    <td><a href="http://wg21.link/cwg1970">1970</a></td>
+    <td><a href="https://wg21.link/cwg1970">1970</a></td>
     <td>NAD</td>
     <td>Ambiguity resolution for <TT>(T())*x</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1971">
-    <td><a href="http://wg21.link/cwg1971">1971</a></td>
+    <td><a href="https://wg21.link/cwg1971">1971</a></td>
     <td>CD4</td>
     <td>Unclear disambiguation of destructor and <TT>operator~</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1972">
-    <td><a href="http://wg21.link/cwg1972">1972</a></td>
+    <td><a href="https://wg21.link/cwg1972">1972</a></td>
     <td>open</td>
     <td>Identifier character restrictions in non-<I>identifier</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1973">
-    <td><a href="http://wg21.link/cwg1973">1973</a></td>
+    <td><a href="https://wg21.link/cwg1973">1973</a></td>
     <td>drafting</td>
     <td>Which <I>parameter-declaration-clause</I> in a <I>lambda-expression</I>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1974">
-    <td><a href="http://wg21.link/cwg1974">1974</a></td>
+    <td><a href="https://wg21.link/cwg1974">1974</a></td>
     <td>open</td>
     <td>Redundant specification of non-type <I>typename-specifier</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1975">
-    <td><a href="http://wg21.link/cwg1975">1975</a></td>
+    <td><a href="https://wg21.link/cwg1975">1975</a></td>
     <td>CD4</td>
     <td>Permissible declarations for <I>exception-specification</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1976">
-    <td><a href="http://wg21.link/cwg1976">1976</a></td>
+    <td><a href="https://wg21.link/cwg1976">1976</a></td>
     <td>NAD</td>
     <td>Ambiguity of <I>namespace-alias</I>es</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1977">
-    <td><a href="http://wg21.link/cwg1977">1977</a></td>
+    <td><a href="https://wg21.link/cwg1977">1977</a></td>
     <td>drafting</td>
     <td>Contradictory results of failed destructor lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1978">
-    <td><a href="http://wg21.link/cwg1978">1978</a></td>
+    <td><a href="https://wg21.link/cwg1978">1978</a></td>
     <td>CD4</td>
     <td>Redundant description of explicit constructor use</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1979">
-    <td><a href="http://wg21.link/cwg1979">1979</a></td>
+    <td><a href="https://wg21.link/cwg1979">1979</a></td>
     <td>drafting</td>
     <td>Alias template specialization in template member definition</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1980">
-    <td><a href="http://wg21.link/cwg1980">1980</a></td>
+    <td><a href="https://wg21.link/cwg1980">1980</a></td>
     <td>drafting</td>
     <td>Equivalent but not functionally-equivalent redeclarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1981">
-    <td><a href="http://wg21.link/cwg1981">1981</a></td>
+    <td><a href="https://wg21.link/cwg1981">1981</a></td>
     <td>CD4</td>
     <td>Implicit contextual conversions and <TT>explicit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1982">
-    <td><a href="http://wg21.link/cwg1982">1982</a></td>
+    <td><a href="https://wg21.link/cwg1982">1982</a></td>
     <td>NAD</td>
     <td>Deduction extending parameter pack</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1983">
-    <td><a href="http://wg21.link/cwg1983">1983</a></td>
+    <td><a href="https://wg21.link/cwg1983">1983</a></td>
     <td>DRWP</td>
     <td>Inappropriate use of <I>virt-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1984">
-    <td><a href="http://wg21.link/cwg1984">1984</a></td>
+    <td><a href="https://wg21.link/cwg1984">1984</a></td>
     <td>NAD</td>
     <td>Lossless narrowing conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1985">
-    <td><a href="http://wg21.link/cwg1985">1985</a></td>
+    <td><a href="https://wg21.link/cwg1985">1985</a></td>
     <td>NAD</td>
     <td>Unknown bound array member with <I>brace-or-equal-initializer</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1986">
-    <td><a href="http://wg21.link/cwg1986">1986</a></td>
+    <td><a href="https://wg21.link/cwg1986">1986</a></td>
     <td>drafting</td>
     <td>odr-use and delayed initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1987">
-    <td><a href="http://wg21.link/cwg1987">1987</a></td>
+    <td><a href="https://wg21.link/cwg1987">1987</a></td>
     <td>NAD</td>
     <td><TT>constexpr</TT> static data members across translation units</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1988">
-    <td><a href="http://wg21.link/cwg1988">1988</a></td>
+    <td><a href="https://wg21.link/cwg1988">1988</a></td>
     <td>CD4</td>
     <td>Ambiguity between dependent and non-dependent bases in implicit member access</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1989">
-    <td><a href="http://wg21.link/cwg1989">1989</a></td>
+    <td><a href="https://wg21.link/cwg1989">1989</a></td>
     <td>drafting</td>
     <td>Insufficient restrictions on parameters of postfix operators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1990">
-    <td><a href="http://wg21.link/cwg1990">1990</a></td>
+    <td><a href="https://wg21.link/cwg1990">1990</a></td>
     <td>CD4</td>
     <td>Ambiguity due to optional <I>decl-specifier-seq</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1991">
-    <td><a href="http://wg21.link/cwg1991">1991</a></td>
+    <td><a href="https://wg21.link/cwg1991">1991</a></td>
     <td>CD4</td>
     <td>Inheriting constructors vs default arguments</td>
     <td class="full" align="center">Clang 3.9</td>
   </tr>
   <tr id="1992">
-    <td><a href="http://wg21.link/cwg1992">1992</a></td>
+    <td><a href="https://wg21.link/cwg1992">1992</a></td>
     <td>CD4</td>
     <td><TT>new (std::nothrow) int[N]</TT> can throw</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1993">
-    <td><a href="http://wg21.link/cwg1993">1993</a></td>
+    <td><a href="https://wg21.link/cwg1993">1993</a></td>
     <td>drafting</td>
     <td>Use of <TT>template&lt;&gt;</TT> defining member of explicit specialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1994">
-    <td><a href="http://wg21.link/cwg1994">1994</a></td>
+    <td><a href="https://wg21.link/cwg1994">1994</a></td>
     <td>dup</td>
     <td>Confusing wording regarding multiple <TT>template&lt;&gt;</TT> prefixes</td>
     <td class="none" align="center">Duplicate of <a href="#529">529</a></td>
   </tr>
   <tr id="1995">
-    <td><a href="http://wg21.link/cwg1995">1995</a></td>
+    <td><a href="https://wg21.link/cwg1995">1995</a></td>
     <td>CD4</td>
     <td><I>exception-specification</I>s and non-type template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="1996">
-    <td><a href="http://wg21.link/cwg1996">1996</a></td>
+    <td><a href="https://wg21.link/cwg1996">1996</a></td>
     <td>drafting</td>
     <td>Reference list-initialization ignores conversion functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="1997">
-    <td><a href="http://wg21.link/cwg1997">1997</a></td>
+    <td><a href="https://wg21.link/cwg1997">1997</a></td>
     <td>drafting</td>
     <td>Placement new and previous initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="1998">
-    <td><a href="http://wg21.link/cwg1998">1998</a></td>
+    <td><a href="https://wg21.link/cwg1998">1998</a></td>
     <td>NAD</td>
     <td>Additional sources of xvalue expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1999">
-    <td><a href="http://wg21.link/cwg1999">1999</a></td>
+    <td><a href="https://wg21.link/cwg1999">1999</a></td>
     <td>CD4</td>
     <td>Representation of source characters as universal-character-names</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2000">
-    <td><a href="http://wg21.link/cwg2000">2000</a></td>
+    <td><a href="https://wg21.link/cwg2000">2000</a></td>
     <td>CD4</td>
     <td><I>header-name</I> outside <TT>#include</TT> directive</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2001">
-    <td><a href="http://wg21.link/cwg2001">2001</a></td>
+    <td><a href="https://wg21.link/cwg2001">2001</a></td>
     <td>CD4</td>
     <td><I>non-directive</I> is underspecified</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2002">
-    <td><a href="http://wg21.link/cwg2002">2002</a></td>
+    <td><a href="https://wg21.link/cwg2002">2002</a></td>
     <td>open</td>
     <td>White space within preprocessing directives</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2003">
-    <td><a href="http://wg21.link/cwg2003">2003</a></td>
+    <td><a href="https://wg21.link/cwg2003">2003</a></td>
     <td>drafting</td>
     <td>Zero-argument macros incorrectly specified</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2004">
-    <td><a href="http://wg21.link/cwg2004">2004</a></td>
+    <td><a href="https://wg21.link/cwg2004">2004</a></td>
     <td>CD4</td>
     <td>Unions with mutable members in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2005">
-    <td><a href="http://wg21.link/cwg2005">2005</a></td>
+    <td><a href="https://wg21.link/cwg2005">2005</a></td>
     <td>NAD</td>
     <td>Incorrect <TT>constexpr</TT> reference initialization requirements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2006">
-    <td><a href="http://wg21.link/cwg2006">2006</a></td>
+    <td><a href="https://wg21.link/cwg2006">2006</a></td>
     <td>CD4</td>
     <td>Cv-qualified <TT>void</TT> types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2007">
-    <td><a href="http://wg21.link/cwg2007">2007</a></td>
+    <td><a href="https://wg21.link/cwg2007">2007</a></td>
     <td>drafting</td>
     <td>Argument-dependent lookup for <TT>operator=</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2008">
-    <td><a href="http://wg21.link/cwg2008">2008</a></td>
+    <td><a href="https://wg21.link/cwg2008">2008</a></td>
     <td>CD4</td>
     <td>Default <I>template-argument</I>s underspecified</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2009">
-    <td><a href="http://wg21.link/cwg2009">2009</a></td>
+    <td><a href="https://wg21.link/cwg2009">2009</a></td>
     <td>open</td>
     <td>Unclear specification of class scope</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2010">
-    <td><a href="http://wg21.link/cwg2010">2010</a></td>
+    <td><a href="https://wg21.link/cwg2010">2010</a></td>
     <td>CD4</td>
     <td><I>exception-specification</I>s and conversion operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2011">
-    <td><a href="http://wg21.link/cwg2011">2011</a></td>
+    <td><a href="https://wg21.link/cwg2011">2011</a></td>
     <td>C++17</td>
     <td>Unclear effect of reference capture of reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2012">
-    <td><a href="http://wg21.link/cwg2012">2012</a></td>
+    <td><a href="https://wg21.link/cwg2012">2012</a></td>
     <td>CD4</td>
     <td>Lifetime of references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2013">
-    <td><a href="http://wg21.link/cwg2013">2013</a></td>
+    <td><a href="https://wg21.link/cwg2013">2013</a></td>
     <td>drafting</td>
     <td>Pointer subtraction in large array</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2014">
-    <td><a href="http://wg21.link/cwg2014">2014</a></td>
+    <td><a href="https://wg21.link/cwg2014">2014</a></td>
     <td>NAD</td>
     <td>Unneeded deallocation signatures</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2015">
-    <td><a href="http://wg21.link/cwg2015">2015</a></td>
+    <td><a href="https://wg21.link/cwg2015">2015</a></td>
     <td>CD4</td>
     <td>odr-use of deleted virtual functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2016">
-    <td><a href="http://wg21.link/cwg2016">2016</a></td>
+    <td><a href="https://wg21.link/cwg2016">2016</a></td>
     <td>CD4</td>
     <td>Confusing wording in description of conversion function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2017">
-    <td><a href="http://wg21.link/cwg2017">2017</a></td>
+    <td><a href="https://wg21.link/cwg2017">2017</a></td>
     <td>CD4</td>
     <td>Flowing off end is not equivalent to no-expression return</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2018">
-    <td><a href="http://wg21.link/cwg2018">2018</a></td>
+    <td><a href="https://wg21.link/cwg2018">2018</a></td>
     <td>drafting</td>
     <td>Qualification conversion vs reference binding</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2019">
-    <td><a href="http://wg21.link/cwg2019">2019</a></td>
+    <td><a href="https://wg21.link/cwg2019">2019</a></td>
     <td>CD4</td>
     <td>Member references omitted from description of storage duration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2020">
-    <td><a href="http://wg21.link/cwg2020">2020</a></td>
+    <td><a href="https://wg21.link/cwg2020">2020</a></td>
     <td>DR</td>
     <td>Inadequate description of odr-use of implicitly-invoked functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2021">
-    <td><a href="http://wg21.link/cwg2021">2021</a></td>
+    <td><a href="https://wg21.link/cwg2021">2021</a></td>
     <td>dup</td>
     <td>Function template redeclaration via alias template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2022">
-    <td><a href="http://wg21.link/cwg2022">2022</a></td>
+    <td><a href="https://wg21.link/cwg2022">2022</a></td>
     <td>CD4</td>
     <td>Copy elision in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2023">
-    <td><a href="http://wg21.link/cwg2023">2023</a></td>
+    <td><a href="https://wg21.link/cwg2023">2023</a></td>
     <td>drafting</td>
     <td>Composite reference result type of conditional operator</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2024">
-    <td><a href="http://wg21.link/cwg2024">2024</a></td>
+    <td><a href="https://wg21.link/cwg2024">2024</a></td>
     <td>CD4</td>
     <td>Dependent types and unexpanded parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2025">
-    <td><a href="http://wg21.link/cwg2025">2025</a></td>
+    <td><a href="https://wg21.link/cwg2025">2025</a></td>
     <td>dup</td>
     <td>Declaration matching via alias templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2026">
-    <td><a href="http://wg21.link/cwg2026">2026</a></td>
+    <td><a href="https://wg21.link/cwg2026">2026</a></td>
     <td>CD4</td>
     <td>Zero-initialization and <TT>constexpr</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2027">
-    <td><a href="http://wg21.link/cwg2027">2027</a></td>
+    <td><a href="https://wg21.link/cwg2027">2027</a></td>
     <td>CD4</td>
     <td>Unclear requirements for multiple <TT>alignas</TT> specifiers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2028">
-    <td><a href="http://wg21.link/cwg2028">2028</a></td>
+    <td><a href="https://wg21.link/cwg2028">2028</a></td>
     <td>drafting</td>
     <td>Converting constructors in rvalue reference initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2029">
-    <td><a href="http://wg21.link/cwg2029">2029</a></td>
+    <td><a href="https://wg21.link/cwg2029">2029</a></td>
     <td>dup</td>
     <td>Abstract class return type in <TT>decltype</TT> operand</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2030">
-    <td><a href="http://wg21.link/cwg2030">2030</a></td>
+    <td><a href="https://wg21.link/cwg2030">2030</a></td>
     <td>NAD</td>
     <td>Access of injected-class-name with template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2031">
-    <td><a href="http://wg21.link/cwg2031">2031</a></td>
+    <td><a href="https://wg21.link/cwg2031">2031</a></td>
     <td>CD4</td>
     <td>Missing incompatibility for <TT>&amp;&amp;</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2032">
-    <td><a href="http://wg21.link/cwg2032">2032</a></td>
+    <td><a href="https://wg21.link/cwg2032">2032</a></td>
     <td>CD4</td>
     <td>Default <I>template-argument</I>s of variable templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2033">
-    <td><a href="http://wg21.link/cwg2033">2033</a></td>
+    <td><a href="https://wg21.link/cwg2033">2033</a></td>
     <td>CD4</td>
     <td>Redundant restriction on partial specialization argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2034">
-    <td><a href="http://wg21.link/cwg2034">2034</a></td>
+    <td><a href="https://wg21.link/cwg2034">2034</a></td>
     <td>NAD</td>
     <td>Deprecating <TT>uncaught_exception()</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2035">
-    <td><a href="http://wg21.link/cwg2035">2035</a></td>
+    <td><a href="https://wg21.link/cwg2035">2035</a></td>
     <td>CD3</td>
     <td>Multi-section example is confusing</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2036">
-    <td><a href="http://wg21.link/cwg2036">2036</a></td>
+    <td><a href="https://wg21.link/cwg2036">2036</a></td>
     <td>NAD</td>
     <td>Refactoring <I>parameters-and-qualifiers</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2037">
-    <td><a href="http://wg21.link/cwg2037">2037</a></td>
+    <td><a href="https://wg21.link/cwg2037">2037</a></td>
     <td>drafting</td>
     <td>Alias templates and template declaration matching</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2038">
-    <td><a href="http://wg21.link/cwg2038">2038</a></td>
+    <td><a href="https://wg21.link/cwg2038">2038</a></td>
     <td>CD4</td>
     <td>Document C++14 incompatibility of new braced deduction rule</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2039">
-    <td><a href="http://wg21.link/cwg2039">2039</a></td>
+    <td><a href="https://wg21.link/cwg2039">2039</a></td>
     <td>CD4</td>
     <td>Constant conversions to <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2040">
-    <td><a href="http://wg21.link/cwg2040">2040</a></td>
+    <td><a href="https://wg21.link/cwg2040">2040</a></td>
     <td>CD4</td>
     <td><I>trailing-return-type</I> no longer ambiguous</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2041">
-    <td><a href="http://wg21.link/cwg2041">2041</a></td>
+    <td><a href="https://wg21.link/cwg2041">2041</a></td>
     <td>CD4</td>
     <td>Namespace for explicit class template specialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2042">
-    <td><a href="http://wg21.link/cwg2042">2042</a></td>
+    <td><a href="https://wg21.link/cwg2042">2042</a></td>
     <td>drafting</td>
     <td>Exceptions and deallocation functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2043">
-    <td><a href="http://wg21.link/cwg2043">2043</a></td>
+    <td><a href="https://wg21.link/cwg2043">2043</a></td>
     <td>drafting</td>
     <td>Generalized template arguments and array-to-pointer decay</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2044">
-    <td><a href="http://wg21.link/cwg2044">2044</a></td>
+    <td><a href="https://wg21.link/cwg2044">2044</a></td>
     <td>CD4</td>
     <td><TT>decltype(auto)</TT> and <TT>void</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2045">
-    <td><a href="http://wg21.link/cwg2045">2045</a></td>
+    <td><a href="https://wg21.link/cwg2045">2045</a></td>
     <td>drafting</td>
     <td>&#8220;Identical&#8221; template parameter lists</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2046">
-    <td><a href="http://wg21.link/cwg2046">2046</a></td>
+    <td><a href="https://wg21.link/cwg2046">2046</a></td>
     <td>C++17</td>
     <td>Incomplete thread specifications</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2047">
-    <td><a href="http://wg21.link/cwg2047">2047</a></td>
+    <td><a href="https://wg21.link/cwg2047">2047</a></td>
     <td>CD4</td>
     <td>Coordinating &#8220;throws anything&#8221; specifications</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2048">
-    <td><a href="http://wg21.link/cwg2048">2048</a></td>
+    <td><a href="https://wg21.link/cwg2048">2048</a></td>
     <td>open</td>
     <td>C-style casts that cast away constness vs <TT>static_cast</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2049">
-    <td><a href="http://wg21.link/cwg2049">2049</a></td>
+    <td><a href="https://wg21.link/cwg2049">2049</a></td>
     <td>drafting</td>
     <td>List initializer in non-type template default argument</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2050">
-    <td><a href="http://wg21.link/cwg2050">2050</a></td>
+    <td><a href="https://wg21.link/cwg2050">2050</a></td>
     <td>NAD</td>
     <td>Consolidate specification of linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2051">
-    <td><a href="http://wg21.link/cwg2051">2051</a></td>
+    <td><a href="https://wg21.link/cwg2051">2051</a></td>
     <td>DR</td>
     <td>Simplifying alias rules</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2052">
-    <td><a href="http://wg21.link/cwg2052">2052</a></td>
+    <td><a href="https://wg21.link/cwg2052">2052</a></td>
     <td>CD4</td>
     <td>Template argument deduction vs overloaded operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2053">
-    <td><a href="http://wg21.link/cwg2053">2053</a></td>
+    <td><a href="https://wg21.link/cwg2053">2053</a></td>
     <td>drafting</td>
     <td><TT>auto</TT> in non-generic lambdas</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2054">
-    <td><a href="http://wg21.link/cwg2054">2054</a></td>
+    <td><a href="https://wg21.link/cwg2054">2054</a></td>
     <td>open</td>
     <td>Missing description of class SFINAE</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2055">
-    <td><a href="http://wg21.link/cwg2055">2055</a></td>
+    <td><a href="https://wg21.link/cwg2055">2055</a></td>
     <td>drafting</td>
     <td>Explicitly-specified non-deduced parameter packs</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2056">
-    <td><a href="http://wg21.link/cwg2056">2056</a></td>
+    <td><a href="https://wg21.link/cwg2056">2056</a></td>
     <td>drafting</td>
     <td>Member function calls in partially-initialized class objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2057">
-    <td><a href="http://wg21.link/cwg2057">2057</a></td>
+    <td><a href="https://wg21.link/cwg2057">2057</a></td>
     <td>drafting</td>
     <td>Template template arguments with default arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2058">
-    <td><a href="http://wg21.link/cwg2058">2058</a></td>
+    <td><a href="https://wg21.link/cwg2058">2058</a></td>
     <td>drafting</td>
     <td>More errors from internal-linkage namespaces</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2059">
-    <td><a href="http://wg21.link/cwg2059">2059</a></td>
+    <td><a href="https://wg21.link/cwg2059">2059</a></td>
     <td>DRWP</td>
     <td>Linkage and deduced return types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2060">
-    <td><a href="http://wg21.link/cwg2060">2060</a></td>
+    <td><a href="https://wg21.link/cwg2060">2060</a></td>
     <td>NAD</td>
     <td>Deduced return type for explicit specialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2061">
-    <td><a href="http://wg21.link/cwg2061">2061</a></td>
+    <td><a href="https://wg21.link/cwg2061">2061</a></td>
     <td>CD4</td>
     <td>Inline namespace after simplifications</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2062">
-    <td><a href="http://wg21.link/cwg2062">2062</a></td>
+    <td><a href="https://wg21.link/cwg2062">2062</a></td>
     <td>drafting</td>
     <td>Class template redeclaration requirements</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2063">
-    <td><a href="http://wg21.link/cwg2063">2063</a></td>
+    <td><a href="https://wg21.link/cwg2063">2063</a></td>
     <td>CD4</td>
     <td>Type/nontype hiding in class scope</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2064">
-    <td><a href="http://wg21.link/cwg2064">2064</a></td>
+    <td><a href="https://wg21.link/cwg2064">2064</a></td>
     <td>CD4</td>
     <td>Conflicting specifications for dependent <I>decltype-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2065">
-    <td><a href="http://wg21.link/cwg2065">2065</a></td>
+    <td><a href="https://wg21.link/cwg2065">2065</a></td>
     <td>drafting</td>
     <td>Current instantiation of a partial specialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2066">
-    <td><a href="http://wg21.link/cwg2066">2066</a></td>
+    <td><a href="https://wg21.link/cwg2066">2066</a></td>
     <td>CD4</td>
     <td>Does type-dependent imply value-dependent?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2067">
-    <td><a href="http://wg21.link/cwg2067">2067</a></td>
+    <td><a href="https://wg21.link/cwg2067">2067</a></td>
     <td>open</td>
     <td>Generated variadic templates requiring empty pack</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2068">
-    <td><a href="http://wg21.link/cwg2068">2068</a></td>
+    <td><a href="https://wg21.link/cwg2068">2068</a></td>
     <td>CD4</td>
     <td>When can/must a defaulted virtual destructor be defined?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2069">
-    <td><a href="http://wg21.link/cwg2069">2069</a></td>
+    <td><a href="https://wg21.link/cwg2069">2069</a></td>
     <td>CD4</td>
     <td>Do destructors have names?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2070">
-    <td><a href="http://wg21.link/cwg2070">2070</a></td>
+    <td><a href="https://wg21.link/cwg2070">2070</a></td>
     <td>drafting</td>
     <td><I>using-declaration</I> with dependent <I>nested-name-specifier</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2071">
-    <td><a href="http://wg21.link/cwg2071">2071</a></td>
+    <td><a href="https://wg21.link/cwg2071">2071</a></td>
     <td>CD4</td>
     <td><TT>typedef</TT> with no declarator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2072">
-    <td><a href="http://wg21.link/cwg2072">2072</a></td>
+    <td><a href="https://wg21.link/cwg2072">2072</a></td>
     <td>drafting</td>
     <td>Default argument instantiation for member functions of templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2073">
-    <td><a href="http://wg21.link/cwg2073">2073</a></td>
+    <td><a href="https://wg21.link/cwg2073">2073</a></td>
     <td>drafting</td>
     <td>Allocating memory for exception objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2074">
-    <td><a href="http://wg21.link/cwg2074">2074</a></td>
+    <td><a href="https://wg21.link/cwg2074">2074</a></td>
     <td>drafting</td>
     <td>Type-dependence of local class of function template</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2075">
-    <td><a href="http://wg21.link/cwg2075">2075</a></td>
+    <td><a href="https://wg21.link/cwg2075">2075</a></td>
     <td>CD4</td>
     <td>Passing short initializer lists to array reference parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2076">
-    <td><a href="http://wg21.link/cwg2076">2076</a></td>
+    <td><a href="https://wg21.link/cwg2076">2076</a></td>
     <td>CD4</td>
     <td>List-initialization of arguments for constructor parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2077">
-    <td><a href="http://wg21.link/cwg2077">2077</a></td>
+    <td><a href="https://wg21.link/cwg2077">2077</a></td>
     <td>drafting</td>
     <td>Overload resolution and invalid rvalue-reference initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2078">
-    <td><a href="http://wg21.link/cwg2078">2078</a></td>
+    <td><a href="https://wg21.link/cwg2078">2078</a></td>
     <td>NAD</td>
     <td>Name lookup of <I>mem-initilizer-id</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2079">
-    <td><a href="http://wg21.link/cwg2079">2079</a></td>
+    <td><a href="https://wg21.link/cwg2079">2079</a></td>
     <td>CD4</td>
     <td><TT>[[</TT> appearing in a <I>balanced-token-seq</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2080">
-    <td><a href="http://wg21.link/cwg2080">2080</a></td>
+    <td><a href="https://wg21.link/cwg2080">2080</a></td>
     <td>drafting</td>
     <td>Example with empty anonymous union member</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2081">
-    <td><a href="http://wg21.link/cwg2081">2081</a></td>
+    <td><a href="https://wg21.link/cwg2081">2081</a></td>
     <td>DRWP</td>
     <td>Deduced return type in redeclaration or specialization of function template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2082">
-    <td><a href="http://wg21.link/cwg2082">2082</a></td>
+    <td><a href="https://wg21.link/cwg2082">2082</a></td>
     <td>CD4</td>
     <td>Referring to parameters in unevaluated operands of default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2083">
-    <td><a href="http://wg21.link/cwg2083">2083</a></td>
+    <td><a href="https://wg21.link/cwg2083">2083</a></td>
     <td>DR</td>
     <td>Incorrect cases of odr-use</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="2084">
-    <td><a href="http://wg21.link/cwg2084">2084</a></td>
+    <td><a href="https://wg21.link/cwg2084">2084</a></td>
     <td>CD4</td>
     <td>NSDMIs and deleted union default constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2085">
-    <td><a href="http://wg21.link/cwg2085">2085</a></td>
+    <td><a href="https://wg21.link/cwg2085">2085</a></td>
     <td>CD4</td>
     <td>Invalid example of adding special member function via default argument</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2086">
-    <td><a href="http://wg21.link/cwg2086">2086</a></td>
+    <td><a href="https://wg21.link/cwg2086">2086</a></td>
     <td>drafting</td>
     <td>Reference odr-use vs implicit capture</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2087">
-    <td><a href="http://wg21.link/cwg2087">2087</a></td>
+    <td><a href="https://wg21.link/cwg2087">2087</a></td>
     <td>NAD</td>
     <td>Left shift of negative value by zero bits</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2088">
-    <td><a href="http://wg21.link/cwg2088">2088</a></td>
+    <td><a href="https://wg21.link/cwg2088">2088</a></td>
     <td>DRWP</td>
     <td>Late tiebreakers in partial ordering</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2089">
-    <td><a href="http://wg21.link/cwg2089">2089</a></td>
+    <td><a href="https://wg21.link/cwg2089">2089</a></td>
     <td>drafting</td>
     <td>Restricting selection of builtin overloaded operators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2090">
-    <td><a href="http://wg21.link/cwg2090">2090</a></td>
+    <td><a href="https://wg21.link/cwg2090">2090</a></td>
     <td>drafting</td>
     <td>Dependency via non-dependent base class</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2091">
-    <td><a href="http://wg21.link/cwg2091">2091</a></td>
+    <td><a href="https://wg21.link/cwg2091">2091</a></td>
     <td>CD4</td>
     <td>Deducing reference non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2092">
-    <td><a href="http://wg21.link/cwg2092">2092</a></td>
+    <td><a href="https://wg21.link/cwg2092">2092</a></td>
     <td>DRWP</td>
     <td>Deduction failure and overload resolution</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2093">
-    <td><a href="http://wg21.link/cwg2093">2093</a></td>
+    <td><a href="https://wg21.link/cwg2093">2093</a></td>
     <td>CD4</td>
     <td>Qualification conversion for pointer-to-member handler matching</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2094">
-    <td><a href="http://wg21.link/cwg2094">2094</a></td>
+    <td><a href="https://wg21.link/cwg2094">2094</a></td>
     <td>C++17</td>
     <td>Trivial copy/move constructor for class with volatile member</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr id="2095">
-    <td><a href="http://wg21.link/cwg2095">2095</a></td>
+    <td><a href="https://wg21.link/cwg2095">2095</a></td>
     <td>CD4</td>
     <td>Capturing rvalue references to functions by copy</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2096">
-    <td><a href="http://wg21.link/cwg2096">2096</a></td>
+    <td><a href="https://wg21.link/cwg2096">2096</a></td>
     <td>CD4</td>
     <td>Constraints on literal unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2097">
-    <td><a href="http://wg21.link/cwg2097">2097</a></td>
+    <td><a href="https://wg21.link/cwg2097">2097</a></td>
     <td>extension</td>
     <td>Lambdas and <TT>noreturn</TT> attribute</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2098">
-    <td><a href="http://wg21.link/cwg2098">2098</a></td>
+    <td><a href="https://wg21.link/cwg2098">2098</a></td>
     <td>CD4</td>
     <td>Is <TT>uncaught_exceptions()</TT> per-thread?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2099">
-    <td><a href="http://wg21.link/cwg2099">2099</a></td>
+    <td><a href="https://wg21.link/cwg2099">2099</a></td>
     <td>CD4</td>
     <td>Inferring the bound of an array static data member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2100">
-    <td><a href="http://wg21.link/cwg2100">2100</a></td>
+    <td><a href="https://wg21.link/cwg2100">2100</a></td>
     <td>C++17</td>
     <td>Value-dependent address of static data member of class template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2101">
-    <td><a href="http://wg21.link/cwg2101">2101</a></td>
+    <td><a href="https://wg21.link/cwg2101">2101</a></td>
     <td>CD4</td>
     <td>Incorrect description of type- and value-dependence</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2102">
-    <td><a href="http://wg21.link/cwg2102">2102</a></td>
+    <td><a href="https://wg21.link/cwg2102">2102</a></td>
     <td>drafting</td>
     <td>Constructor checking in <I>new-expression</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2103">
-    <td><a href="http://wg21.link/cwg2103">2103</a></td>
+    <td><a href="https://wg21.link/cwg2103">2103</a></td>
     <td>DR</td>
     <td>Lvalue-to-rvalue conversion is irrelevant in odr-use of a reference</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="2104">
-    <td><a href="http://wg21.link/cwg2104">2104</a></td>
+    <td><a href="https://wg21.link/cwg2104">2104</a></td>
     <td>CD4</td>
     <td>Internal-linkage <TT>constexpr</TT> references and ODR requirements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2105">
-    <td><a href="http://wg21.link/cwg2105">2105</a></td>
+    <td><a href="https://wg21.link/cwg2105">2105</a></td>
     <td>open</td>
     <td>When do the arguments for a parameter pack end?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2106">
-    <td><a href="http://wg21.link/cwg2106">2106</a></td>
+    <td><a href="https://wg21.link/cwg2106">2106</a></td>
     <td>CD4</td>
     <td>Unclear restrictions on use of function-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2107">
-    <td><a href="http://wg21.link/cwg2107">2107</a></td>
+    <td><a href="https://wg21.link/cwg2107">2107</a></td>
     <td>CD4</td>
     <td>Lifetime of temporaries for default arguments in array copying</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2108">
-    <td><a href="http://wg21.link/cwg2108">2108</a></td>
+    <td><a href="https://wg21.link/cwg2108">2108</a></td>
     <td>drafting</td>
     <td>Conversions to non-class prvalues in reference initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2109">
-    <td><a href="http://wg21.link/cwg2109">2109</a></td>
+    <td><a href="https://wg21.link/cwg2109">2109</a></td>
     <td>CD4</td>
     <td>Value dependence underspecified</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2110">
-    <td><a href="http://wg21.link/cwg2110">2110</a></td>
+    <td><a href="https://wg21.link/cwg2110">2110</a></td>
     <td>drafting</td>
     <td>Overload resolution for base class conversion and reference/non-reference</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2111">
-    <td><a href="http://wg21.link/cwg2111">2111</a></td>
+    <td><a href="https://wg21.link/cwg2111">2111</a></td>
     <td>extension</td>
     <td>Array temporaries in reference binding</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="2112">
-    <td><a href="http://wg21.link/cwg2112">2112</a></td>
+    <td><a href="https://wg21.link/cwg2112">2112</a></td>
     <td>drafting</td>
     <td><TT>new auto{x}</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2113">
-    <td><a href="http://wg21.link/cwg2113">2113</a></td>
+    <td><a href="https://wg21.link/cwg2113">2113</a></td>
     <td>CD4</td>
     <td>Incompete specification of types for declarators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2114">
-    <td><a href="http://wg21.link/cwg2114">2114</a></td>
+    <td><a href="https://wg21.link/cwg2114">2114</a></td>
     <td>CD3</td>
     <td>Missing description of incompatibility from aggregate NSDMIs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2115">
-    <td><a href="http://wg21.link/cwg2115">2115</a></td>
+    <td><a href="https://wg21.link/cwg2115">2115</a></td>
     <td>drafting</td>
     <td>Order of implicit destruction vs release of automatic storage</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2116">
-    <td><a href="http://wg21.link/cwg2116">2116</a></td>
+    <td><a href="https://wg21.link/cwg2116">2116</a></td>
     <td>drafting</td>
     <td>Direct or copy initialization for omitted aggregate initializers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2117">
-    <td><a href="http://wg21.link/cwg2117">2117</a></td>
+    <td><a href="https://wg21.link/cwg2117">2117</a></td>
     <td>drafting</td>
     <td>Explicit specializations and <TT>constexpr</TT> function templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2118">
-    <td><a href="http://wg21.link/cwg2118">2118</a></td>
+    <td><a href="https://wg21.link/cwg2118">2118</a></td>
     <td>open</td>
     <td>Stateful metaprogramming via friend injection</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2119">
-    <td><a href="http://wg21.link/cwg2119">2119</a></td>
+    <td><a href="https://wg21.link/cwg2119">2119</a></td>
     <td>NAD</td>
     <td>Disambiguation of multi-level covariant return type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2120">
-    <td><a href="http://wg21.link/cwg2120">2120</a></td>
+    <td><a href="https://wg21.link/cwg2120">2120</a></td>
     <td>CD4</td>
     <td>Array as first non-static data member in standard-layout class</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr class="open" id="2121">
-    <td><a href="http://wg21.link/cwg2121">2121</a></td>
+    <td><a href="https://wg21.link/cwg2121">2121</a></td>
     <td>drafting</td>
     <td>More flexible lambda syntax</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2122">
-    <td><a href="http://wg21.link/cwg2122">2122</a></td>
+    <td><a href="https://wg21.link/cwg2122">2122</a></td>
     <td>CD4</td>
     <td>Glvalues of <TT>void</TT> type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2123">
-    <td><a href="http://wg21.link/cwg2123">2123</a></td>
+    <td><a href="https://wg21.link/cwg2123">2123</a></td>
     <td>open</td>
     <td>Omitted constant initialization of local static variables</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2124">
-    <td><a href="http://wg21.link/cwg2124">2124</a></td>
+    <td><a href="https://wg21.link/cwg2124">2124</a></td>
     <td>CD4</td>
     <td>Signature of constructor template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2125">
-    <td><a href="http://wg21.link/cwg2125">2125</a></td>
+    <td><a href="https://wg21.link/cwg2125">2125</a></td>
     <td>extension</td>
     <td>Copy elision and comma operator</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="2126">
-    <td><a href="http://wg21.link/cwg2126">2126</a></td>
+    <td><a href="https://wg21.link/cwg2126">2126</a></td>
     <td>drafting</td>
     <td>Lifetime-extended temporaries in constant expressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2127">
-    <td><a href="http://wg21.link/cwg2127">2127</a></td>
+    <td><a href="https://wg21.link/cwg2127">2127</a></td>
     <td>drafting</td>
     <td>Partial specialization and nullptr</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2128">
-    <td><a href="http://wg21.link/cwg2128">2128</a></td>
+    <td><a href="https://wg21.link/cwg2128">2128</a></td>
     <td>drafting</td>
     <td>Imprecise rule for reference member initializer</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2129">
-    <td><a href="http://wg21.link/cwg2129">2129</a></td>
+    <td><a href="https://wg21.link/cwg2129">2129</a></td>
     <td>CD4</td>
     <td>Non-object prvalues and constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2130">
-    <td><a href="http://wg21.link/cwg2130">2130</a></td>
+    <td><a href="https://wg21.link/cwg2130">2130</a></td>
     <td>CD4</td>
     <td>Over-aligned types in <I>new-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2131">
-    <td><a href="http://wg21.link/cwg2131">2131</a></td>
+    <td><a href="https://wg21.link/cwg2131">2131</a></td>
     <td>drafting</td>
     <td>Ambiguity with <I>opaque-enum-declaration</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2132">
-    <td><a href="http://wg21.link/cwg2132">2132</a></td>
+    <td><a href="https://wg21.link/cwg2132">2132</a></td>
     <td>extension</td>
     <td>Deprecated default generated copy constructors</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2133">
-    <td><a href="http://wg21.link/cwg2133">2133</a></td>
+    <td><a href="https://wg21.link/cwg2133">2133</a></td>
     <td>DRWP</td>
     <td>Converting <TT>std::nullptr_t</TT> to <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2134">
-    <td><a href="http://wg21.link/cwg2134">2134</a></td>
+    <td><a href="https://wg21.link/cwg2134">2134</a></td>
     <td>NAD</td>
     <td>Objectless references to non-static member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2135">
-    <td><a href="http://wg21.link/cwg2135">2135</a></td>
+    <td><a href="https://wg21.link/cwg2135">2135</a></td>
     <td>NAD</td>
     <td><I>mem-initializer</I>s for virtual bases of abstract classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2136">
-    <td><a href="http://wg21.link/cwg2136">2136</a></td>
+    <td><a href="https://wg21.link/cwg2136">2136</a></td>
     <td>NAD</td>
     <td>Argument-dependent lookup and initializer lists</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2137">
-    <td><a href="http://wg21.link/cwg2137">2137</a></td>
+    <td><a href="https://wg21.link/cwg2137">2137</a></td>
     <td>CD4</td>
     <td>List-initialization from object of same type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2138">
-    <td><a href="http://wg21.link/cwg2138">2138</a></td>
+    <td><a href="https://wg21.link/cwg2138">2138</a></td>
     <td>NAD</td>
     <td>Explicit member specialization vs implicit instantiation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2139">
-    <td><a href="http://wg21.link/cwg2139">2139</a></td>
+    <td><a href="https://wg21.link/cwg2139">2139</a></td>
     <td>NAD</td>
     <td>Floating-point requirements for integer representation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2140">
-    <td><a href="http://wg21.link/cwg2140">2140</a></td>
+    <td><a href="https://wg21.link/cwg2140">2140</a></td>
     <td>CD4</td>
     <td>Lvalue-to-rvalue conversion of <TT>std::nullptr_t</TT></td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="2141">
-    <td><a href="http://wg21.link/cwg2141">2141</a></td>
+    <td><a href="https://wg21.link/cwg2141">2141</a></td>
     <td>CD4</td>
     <td>Ambiguity in <I>new-expression</I> with <I>elaborated-type-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2142">
-    <td><a href="http://wg21.link/cwg2142">2142</a></td>
+    <td><a href="https://wg21.link/cwg2142">2142</a></td>
     <td>NAD</td>
     <td>Missing definition of associated classes and namespaces</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2143">
-    <td><a href="http://wg21.link/cwg2143">2143</a></td>
+    <td><a href="https://wg21.link/cwg2143">2143</a></td>
     <td>C++17</td>
     <td>Value-dependency via injected-class-name</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2144">
-    <td><a href="http://wg21.link/cwg2144">2144</a></td>
+    <td><a href="https://wg21.link/cwg2144">2144</a></td>
     <td>drafting</td>
     <td>Function/variable declaration ambiguity</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2145">
-    <td><a href="http://wg21.link/cwg2145">2145</a></td>
+    <td><a href="https://wg21.link/cwg2145">2145</a></td>
     <td>CD4</td>
     <td>Parenthesized declarator in function definition</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2146">
-    <td><a href="http://wg21.link/cwg2146">2146</a></td>
+    <td><a href="https://wg21.link/cwg2146">2146</a></td>
     <td>CD4</td>
     <td>Scalar object vs memory location in definition of &#8220;unsequenced&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2147">
-    <td><a href="http://wg21.link/cwg2147">2147</a></td>
+    <td><a href="https://wg21.link/cwg2147">2147</a></td>
     <td>CD4</td>
     <td>Initializer-list arguments and pack deduction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2148">
-    <td><a href="http://wg21.link/cwg2148">2148</a></td>
+    <td><a href="https://wg21.link/cwg2148">2148</a></td>
     <td>drafting</td>
     <td>Thread storage duration and order of initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2149">
-    <td><a href="http://wg21.link/cwg2149">2149</a></td>
+    <td><a href="https://wg21.link/cwg2149">2149</a></td>
     <td>drafting</td>
     <td>Brace elision and array length deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2150">
-    <td><a href="http://wg21.link/cwg2150">2150</a></td>
+    <td><a href="https://wg21.link/cwg2150">2150</a></td>
     <td>CD3</td>
     <td>Initializer list array lifetime</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2151">
-    <td><a href="http://wg21.link/cwg2151">2151</a></td>
+    <td><a href="https://wg21.link/cwg2151">2151</a></td>
     <td>CD4</td>
     <td>Exception object is not created</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2152">
-    <td><a href="http://wg21.link/cwg2152">2152</a></td>
+    <td><a href="https://wg21.link/cwg2152">2152</a></td>
     <td>NAD</td>
     <td>Can an alternative token be used as a <I>ud-suffix</I>?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2153">
-    <td><a href="http://wg21.link/cwg2153">2153</a></td>
+    <td><a href="https://wg21.link/cwg2153">2153</a></td>
     <td>CD4</td>
     <td><I>pure-specifier</I> in friend declaration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2154">
-    <td><a href="http://wg21.link/cwg2154">2154</a></td>
+    <td><a href="https://wg21.link/cwg2154">2154</a></td>
     <td>CD4</td>
     <td>Ambiguity of <I>pure-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2155">
-    <td><a href="http://wg21.link/cwg2155">2155</a></td>
+    <td><a href="https://wg21.link/cwg2155">2155</a></td>
     <td>C++17</td>
     <td>Defining classes and enumerations via <I>using-declaration</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2156">
-    <td><a href="http://wg21.link/cwg2156">2156</a></td>
+    <td><a href="https://wg21.link/cwg2156">2156</a></td>
     <td>CD4</td>
     <td>Definition of enumeration declared by <I>using-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2157">
-    <td><a href="http://wg21.link/cwg2157">2157</a></td>
+    <td><a href="https://wg21.link/cwg2157">2157</a></td>
     <td>CD4</td>
     <td>Further disambiguation of enumeration <I>elaborated-type-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2158">
-    <td><a href="http://wg21.link/cwg2158">2158</a></td>
+    <td><a href="https://wg21.link/cwg2158">2158</a></td>
     <td>drafting</td>
     <td>Polymorphic behavior during destruction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2159">
-    <td><a href="http://wg21.link/cwg2159">2159</a></td>
+    <td><a href="https://wg21.link/cwg2159">2159</a></td>
     <td>NAD</td>
     <td>Lambda capture and local <TT>thread_local</TT> variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2160">
-    <td><a href="http://wg21.link/cwg2160">2160</a></td>
+    <td><a href="https://wg21.link/cwg2160">2160</a></td>
     <td>open</td>
     <td>Issues with partial ordering</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2161">
-    <td><a href="http://wg21.link/cwg2161">2161</a></td>
+    <td><a href="https://wg21.link/cwg2161">2161</a></td>
     <td>NAD</td>
     <td>Explicit instantiation declaration and &#8220;preceding initialization&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2162">
-    <td><a href="http://wg21.link/cwg2162">2162</a></td>
+    <td><a href="https://wg21.link/cwg2162">2162</a></td>
     <td>CD3</td>
     <td>Capturing <TT>this</TT> by reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2163">
-    <td><a href="http://wg21.link/cwg2163">2163</a></td>
+    <td><a href="https://wg21.link/cwg2163">2163</a></td>
     <td>CD4</td>
     <td>Labels in <TT>constexpr</TT> functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2164">
-    <td><a href="http://wg21.link/cwg2164">2164</a></td>
+    <td><a href="https://wg21.link/cwg2164">2164</a></td>
     <td>DRWP</td>
     <td>Name hiding and <I>using-directive</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2165">
-    <td><a href="http://wg21.link/cwg2165">2165</a></td>
+    <td><a href="https://wg21.link/cwg2165">2165</a></td>
     <td>drafting</td>
     <td>Namespaces, declarative regions, and translation units</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2166">
-    <td><a href="http://wg21.link/cwg2166">2166</a></td>
+    <td><a href="https://wg21.link/cwg2166">2166</a></td>
     <td>drafting</td>
     <td>Unclear meaning of &#8220;undefined <TT>constexpr</TT> function&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2167">
-    <td><a href="http://wg21.link/cwg2167">2167</a></td>
+    <td><a href="https://wg21.link/cwg2167">2167</a></td>
     <td>CD4</td>
     <td>Non-member references with lifetimes within the current evaluation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2168">
-    <td><a href="http://wg21.link/cwg2168">2168</a></td>
+    <td><a href="https://wg21.link/cwg2168">2168</a></td>
     <td>open</td>
     <td>Narrowing conversions and +/- infinity</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2169">
-    <td><a href="http://wg21.link/cwg2169">2169</a></td>
+    <td><a href="https://wg21.link/cwg2169">2169</a></td>
     <td>extension</td>
     <td>Narrowing conversions and overload resolution</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2170">
-    <td><a href="http://wg21.link/cwg2170">2170</a></td>
+    <td><a href="https://wg21.link/cwg2170">2170</a></td>
     <td>DR</td>
     <td>Unclear definition of odr-use for arrays</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="2171">
-    <td><a href="http://wg21.link/cwg2171">2171</a></td>
+    <td><a href="https://wg21.link/cwg2171">2171</a></td>
     <td>CD4</td>
     <td>Triviality of copy constructor with less-qualified parameter</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2172">
-    <td><a href="http://wg21.link/cwg2172">2172</a></td>
+    <td><a href="https://wg21.link/cwg2172">2172</a></td>
     <td>drafting</td>
     <td>Multiple exceptions with one exception object</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2173">
-    <td><a href="http://wg21.link/cwg2173">2173</a></td>
+    <td><a href="https://wg21.link/cwg2173">2173</a></td>
     <td>open</td>
     <td>Partial specialization with non-deduced contexts</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2174">
-    <td><a href="http://wg21.link/cwg2174">2174</a></td>
+    <td><a href="https://wg21.link/cwg2174">2174</a></td>
     <td>C++17</td>
     <td>Unclear rules for friend definitions in templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2175">
-    <td><a href="http://wg21.link/cwg2175">2175</a></td>
+    <td><a href="https://wg21.link/cwg2175">2175</a></td>
     <td>CD4</td>
     <td>Ambiguity with attribute in conversion operator declaration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2176">
-    <td><a href="http://wg21.link/cwg2176">2176</a></td>
+    <td><a href="https://wg21.link/cwg2176">2176</a></td>
     <td>CD4</td>
     <td>Destroying the returned object when a destructor throws</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2177">
-    <td><a href="http://wg21.link/cwg2177">2177</a></td>
+    <td><a href="https://wg21.link/cwg2177">2177</a></td>
     <td>DRWP</td>
     <td>Placement <TT>operator delete</TT> and parameter copies</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2178">
-    <td><a href="http://wg21.link/cwg2178">2178</a></td>
+    <td><a href="https://wg21.link/cwg2178">2178</a></td>
     <td>NAD</td>
     <td>Substitution of dependent template arguments in default template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2179">
-    <td><a href="http://wg21.link/cwg2179">2179</a></td>
+    <td><a href="https://wg21.link/cwg2179">2179</a></td>
     <td>drafting</td>
     <td>Required diagnostic for partial specialization after first use</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2180">
-    <td><a href="http://wg21.link/cwg2180">2180</a></td>
+    <td><a href="https://wg21.link/cwg2180">2180</a></td>
     <td>CD4</td>
     <td>Virtual bases in destructors and defaulted assignment operators</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="2181">
-    <td><a href="http://wg21.link/cwg2181">2181</a></td>
+    <td><a href="https://wg21.link/cwg2181">2181</a></td>
     <td>drafting</td>
     <td>Normative requirements in an informative Annex</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2182">
-    <td><a href="http://wg21.link/cwg2182">2182</a></td>
+    <td><a href="https://wg21.link/cwg2182">2182</a></td>
     <td>drafting</td>
     <td>Pointer arithmetic in array-like containers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2183">
-    <td><a href="http://wg21.link/cwg2183">2183</a></td>
+    <td><a href="https://wg21.link/cwg2183">2183</a></td>
     <td>NAD</td>
     <td>Problems in description of potential exceptions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2184">
-    <td><a href="http://wg21.link/cwg2184">2184</a></td>
+    <td><a href="https://wg21.link/cwg2184">2184</a></td>
     <td>CD4</td>
     <td>Missing C compatibility entry for decrement of <TT>bool</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2185">
-    <td><a href="http://wg21.link/cwg2185">2185</a></td>
+    <td><a href="https://wg21.link/cwg2185">2185</a></td>
     <td>open</td>
     <td>Cv-qualified numeric types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2186">
-    <td><a href="http://wg21.link/cwg2186">2186</a></td>
+    <td><a href="https://wg21.link/cwg2186">2186</a></td>
     <td>drafting</td>
     <td>Unclear point that &#8220;preceding initialization&#8221; must precede</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2187">
-    <td><a href="http://wg21.link/cwg2187">2187</a></td>
+    <td><a href="https://wg21.link/cwg2187">2187</a></td>
     <td>drafting</td>
     <td>Protected members and access via <I>qualified-id</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2188">
-    <td><a href="http://wg21.link/cwg2188">2188</a></td>
+    <td><a href="https://wg21.link/cwg2188">2188</a></td>
     <td>open</td>
     <td><I>empty-declaration</I> ambiguity</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2189">
-    <td><a href="http://wg21.link/cwg2189">2189</a></td>
+    <td><a href="https://wg21.link/cwg2189">2189</a></td>
     <td>open</td>
     <td>Surrogate call template</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2190">
-    <td><a href="http://wg21.link/cwg2190">2190</a></td>
+    <td><a href="https://wg21.link/cwg2190">2190</a></td>
     <td>open</td>
     <td>Insufficient specification of <TT>__has_include</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2191">
-    <td><a href="http://wg21.link/cwg2191">2191</a></td>
+    <td><a href="https://wg21.link/cwg2191">2191</a></td>
     <td>C++17</td>
     <td>Incorrect result for <TT>noexcept(typeid(v))</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2192">
-    <td><a href="http://wg21.link/cwg2192">2192</a></td>
+    <td><a href="https://wg21.link/cwg2192">2192</a></td>
     <td>open</td>
     <td>Constant expressions and order-of-eval undefined behavior</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2193">
-    <td><a href="http://wg21.link/cwg2193">2193</a></td>
+    <td><a href="https://wg21.link/cwg2193">2193</a></td>
     <td>NAD</td>
     <td><TT>numeric_limits&lt;int&gt;::radix</TT> and <TT>digits</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2194">
-    <td><a href="http://wg21.link/cwg2194">2194</a></td>
+    <td><a href="https://wg21.link/cwg2194">2194</a></td>
     <td>review</td>
     <td>Impossible case in list initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2195">
-    <td><a href="http://wg21.link/cwg2195">2195</a></td>
+    <td><a href="https://wg21.link/cwg2195">2195</a></td>
     <td>open</td>
     <td>Unsolicited reading of trailing volatile members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2196">
-    <td><a href="http://wg21.link/cwg2196">2196</a></td>
+    <td><a href="https://wg21.link/cwg2196">2196</a></td>
     <td>C++17</td>
     <td>Zero-initialization with virtual base classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2197">
-    <td><a href="http://wg21.link/cwg2197">2197</a></td>
+    <td><a href="https://wg21.link/cwg2197">2197</a></td>
     <td>review</td>
     <td>Overload resolution and deleted special member functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2198">
-    <td><a href="http://wg21.link/cwg2198">2198</a></td>
+    <td><a href="https://wg21.link/cwg2198">2198</a></td>
     <td>C++17</td>
     <td>Linkage of enumerators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2199">
-    <td><a href="http://wg21.link/cwg2199">2199</a></td>
+    <td><a href="https://wg21.link/cwg2199">2199</a></td>
     <td>drafting</td>
     <td>Typedefs and tags</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2200">
-    <td><a href="http://wg21.link/cwg2200">2200</a></td>
+    <td><a href="https://wg21.link/cwg2200">2200</a></td>
     <td>NAD</td>
     <td>Conversions in template argument deduction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2201">
-    <td><a href="http://wg21.link/cwg2201">2201</a></td>
+    <td><a href="https://wg21.link/cwg2201">2201</a></td>
     <td>C++17</td>
     <td>Cv-qualification of array types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2202">
-    <td><a href="http://wg21.link/cwg2202">2202</a></td>
+    <td><a href="https://wg21.link/cwg2202">2202</a></td>
     <td>drafting</td>
     <td>When does default argument instantiation occur?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2203">
-    <td><a href="http://wg21.link/cwg2203">2203</a></td>
+    <td><a href="https://wg21.link/cwg2203">2203</a></td>
     <td>drafting</td>
     <td>Defaulted copy/move constructors and UDCs</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2204">
-    <td><a href="http://wg21.link/cwg2204">2204</a></td>
+    <td><a href="https://wg21.link/cwg2204">2204</a></td>
     <td>NAD</td>
     <td>Naming delegated constructors</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2205">
-    <td><a href="http://wg21.link/cwg2205">2205</a></td>
+    <td><a href="https://wg21.link/cwg2205">2205</a></td>
     <td>C++17</td>
     <td>Restrictions on use of <TT>alignas</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2206">
-    <td><a href="http://wg21.link/cwg2206">2206</a></td>
+    <td><a href="https://wg21.link/cwg2206">2206</a></td>
     <td>C++17</td>
     <td>Composite type of object and function pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2207">
-    <td><a href="http://wg21.link/cwg2207">2207</a></td>
+    <td><a href="https://wg21.link/cwg2207">2207</a></td>
     <td>tentatively ready</td>
     <td>Alignment of allocation function return value</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2208">
-    <td><a href="http://wg21.link/cwg2208">2208</a></td>
+    <td><a href="https://wg21.link/cwg2208">2208</a></td>
     <td>NAD</td>
     <td><I>static_assert-declaration</I> does not declare a member</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2209">
-    <td><a href="http://wg21.link/cwg2209">2209</a></td>
+    <td><a href="https://wg21.link/cwg2209">2209</a></td>
     <td>NAD</td>
     <td>Destruction of constructed array elements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2210">
-    <td><a href="http://wg21.link/cwg2210">2210</a></td>
+    <td><a href="https://wg21.link/cwg2210">2210</a></td>
     <td>NAD</td>
     <td>Principal/target constructor confusion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2211">
-    <td><a href="http://wg21.link/cwg2211">2211</a></td>
+    <td><a href="https://wg21.link/cwg2211">2211</a></td>
     <td>C++17</td>
     <td>Hiding by lambda captures and parameters</td>
     <td class="full" align="center">Clang 8</td>
   </tr>
   <tr class="open" id="2212">
-    <td><a href="http://wg21.link/cwg2212">2212</a></td>
+    <td><a href="https://wg21.link/cwg2212">2212</a></td>
     <td>open</td>
     <td>Typedef changing linkage after use</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2213">
-    <td><a href="http://wg21.link/cwg2213">2213</a></td>
+    <td><a href="https://wg21.link/cwg2213">2213</a></td>
     <td>drafting</td>
     <td>Forward declaration of partial specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2214">
-    <td><a href="http://wg21.link/cwg2214">2214</a></td>
+    <td><a href="https://wg21.link/cwg2214">2214</a></td>
     <td>C++17</td>
     <td>Missing requirement on representation of integer values</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2215">
-    <td><a href="http://wg21.link/cwg2215">2215</a></td>
+    <td><a href="https://wg21.link/cwg2215">2215</a></td>
     <td>review</td>
     <td>Redundant description of language linkage in function call</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2216">
-    <td><a href="http://wg21.link/cwg2216">2216</a></td>
+    <td><a href="https://wg21.link/cwg2216">2216</a></td>
     <td>NAD</td>
     <td>Exception specifications in unevaluated contexts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2217">
-    <td><a href="http://wg21.link/cwg2217">2217</a></td>
+    <td><a href="https://wg21.link/cwg2217">2217</a></td>
     <td>NAD</td>
     <td><TT>constexpr</TT> constructors for non-literal types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2218">
-    <td><a href="http://wg21.link/cwg2218">2218</a></td>
+    <td><a href="https://wg21.link/cwg2218">2218</a></td>
     <td>C++17</td>
     <td>Ambiguity and namespace aliases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2219">
-    <td><a href="http://wg21.link/cwg2219">2219</a></td>
+    <td><a href="https://wg21.link/cwg2219">2219</a></td>
     <td>drafting</td>
     <td>Dynamically-unreachable handlers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2220">
-    <td><a href="http://wg21.link/cwg2220">2220</a></td>
+    <td><a href="https://wg21.link/cwg2220">2220</a></td>
     <td>C++17</td>
     <td>Hiding index variable in range-based <TT>for</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2221">
-    <td><a href="http://wg21.link/cwg2221">2221</a></td>
+    <td><a href="https://wg21.link/cwg2221">2221</a></td>
     <td>review</td>
     <td>Copying volatile objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2222">
-    <td><a href="http://wg21.link/cwg2222">2222</a></td>
+    <td><a href="https://wg21.link/cwg2222">2222</a></td>
     <td>drafting</td>
     <td>Additional contexts where instantiation is not required</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2223">
-    <td><a href="http://wg21.link/cwg2223">2223</a></td>
+    <td><a href="https://wg21.link/cwg2223">2223</a></td>
     <td>drafting</td>
     <td>Multiple <TT>alignas</TT> specifiers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2224">
-    <td><a href="http://wg21.link/cwg2224">2224</a></td>
+    <td><a href="https://wg21.link/cwg2224">2224</a></td>
     <td>C++17</td>
     <td>Member subobjects and base-class casts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2225">
-    <td><a href="http://wg21.link/cwg2225">2225</a></td>
+    <td><a href="https://wg21.link/cwg2225">2225</a></td>
     <td>NAD</td>
     <td><TT>reinterpret_cast</TT> to same floating-point type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2226">
-    <td><a href="http://wg21.link/cwg2226">2226</a></td>
+    <td><a href="https://wg21.link/cwg2226">2226</a></td>
     <td>DRWP</td>
     <td>Xvalues vs lvalues in conditional expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2227">
-    <td><a href="http://wg21.link/cwg2227">2227</a></td>
+    <td><a href="https://wg21.link/cwg2227">2227</a></td>
     <td>DRWP</td>
     <td>Destructor access and default member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2228">
-    <td><a href="http://wg21.link/cwg2228">2228</a></td>
+    <td><a href="https://wg21.link/cwg2228">2228</a></td>
     <td>review</td>
     <td>Ambiguity resolution for cast to function type</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2229">
-    <td><a href="http://wg21.link/cwg2229">2229</a></td>
+    <td><a href="https://wg21.link/cwg2229">2229</a></td>
     <td>DRWP</td>
     <td>Volatile unnamed bit-fields</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="2230">
-    <td><a href="http://wg21.link/cwg2230">2230</a></td>
+    <td><a href="https://wg21.link/cwg2230">2230</a></td>
     <td>NAD</td>
     <td>Linkage of <TT>extern "C"</TT> function in unnamed namespace</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2231">
-    <td><a href="http://wg21.link/cwg2231">2231</a></td>
+    <td><a href="https://wg21.link/cwg2231">2231</a></td>
     <td>NAD</td>
     <td>Class member access to static data member template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2232">
-    <td><a href="http://wg21.link/cwg2232">2232</a></td>
+    <td><a href="https://wg21.link/cwg2232">2232</a></td>
     <td>open</td>
     <td><TT>thread_local</TT> anonymous unions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2233">
-    <td><a href="http://wg21.link/cwg2233">2233</a></td>
+    <td><a href="https://wg21.link/cwg2233">2233</a></td>
     <td>DRWP</td>
     <td>Function parameter packs following default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2234">
-    <td><a href="http://wg21.link/cwg2234">2234</a></td>
+    <td><a href="https://wg21.link/cwg2234">2234</a></td>
     <td>DRWP</td>
     <td>Missing rules for <I>simple-template-id</I> as <I>class-name</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2235">
-    <td><a href="http://wg21.link/cwg2235">2235</a></td>
+    <td><a href="https://wg21.link/cwg2235">2235</a></td>
     <td>DRWP</td>
     <td>Partial ordering and non-dependent types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2236">
-    <td><a href="http://wg21.link/cwg2236">2236</a></td>
+    <td><a href="https://wg21.link/cwg2236">2236</a></td>
     <td>drafting</td>
     <td>When is an alias template specialization dependent?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2237">
-    <td><a href="http://wg21.link/cwg2237">2237</a></td>
+    <td><a href="https://wg21.link/cwg2237">2237</a></td>
     <td>WP</td>
     <td>Can a <I>template-id</I> name a constructor?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2238">
-    <td><a href="http://wg21.link/cwg2238">2238</a></td>
+    <td><a href="https://wg21.link/cwg2238">2238</a></td>
     <td>NAD</td>
     <td>Contradictory alignment requirements for allocation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2239">
-    <td><a href="http://wg21.link/cwg2239">2239</a></td>
+    <td><a href="https://wg21.link/cwg2239">2239</a></td>
     <td>NAD</td>
     <td>Sized deallocation with a trivial destructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2240">
-    <td><a href="http://wg21.link/cwg2240">2240</a></td>
+    <td><a href="https://wg21.link/cwg2240">2240</a></td>
     <td>NAD</td>
     <td><TT>this</TT> is not odr-used in a constant expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2241">
-    <td><a href="http://wg21.link/cwg2241">2241</a></td>
+    <td><a href="https://wg21.link/cwg2241">2241</a></td>
     <td>DRWP</td>
     <td>Overload resolution is not invoked with a single function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2242">
-    <td><a href="http://wg21.link/cwg2242">2242</a></td>
+    <td><a href="https://wg21.link/cwg2242">2242</a></td>
     <td>drafting</td>
     <td>ODR violation with constant initialization possibly omitted</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2243">
-    <td><a href="http://wg21.link/cwg2243">2243</a></td>
+    <td><a href="https://wg21.link/cwg2243">2243</a></td>
     <td>drafting</td>
     <td>Incorrect use of implicit conversion sequence</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2244">
-    <td><a href="http://wg21.link/cwg2244">2244</a></td>
+    <td><a href="https://wg21.link/cwg2244">2244</a></td>
     <td>open</td>
     <td>Base class access in aggregate initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2245">
-    <td><a href="http://wg21.link/cwg2245">2245</a></td>
+    <td><a href="https://wg21.link/cwg2245">2245</a></td>
     <td>drafting</td>
     <td>Point of instantiation of incomplete class template</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2246">
-    <td><a href="http://wg21.link/cwg2246">2246</a></td>
+    <td><a href="https://wg21.link/cwg2246">2246</a></td>
     <td>drafting</td>
     <td>Access of indirect virtual base class constructors</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2247">
-    <td><a href="http://wg21.link/cwg2247">2247</a></td>
+    <td><a href="https://wg21.link/cwg2247">2247</a></td>
     <td>C++17</td>
     <td>Lambda capture and variable argument list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2248">
-    <td><a href="http://wg21.link/cwg2248">2248</a></td>
+    <td><a href="https://wg21.link/cwg2248">2248</a></td>
     <td>C++17</td>
     <td>Problems with sized delete</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2249">
-    <td><a href="http://wg21.link/cwg2249">2249</a></td>
+    <td><a href="https://wg21.link/cwg2249">2249</a></td>
     <td>DRWP</td>
     <td><I>identifier</I>s and <I>id-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2250">
-    <td><a href="http://wg21.link/cwg2250">2250</a></td>
+    <td><a href="https://wg21.link/cwg2250">2250</a></td>
     <td>open</td>
     <td>Implicit instantiation, destruction, and TUs</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2251">
-    <td><a href="http://wg21.link/cwg2251">2251</a></td>
+    <td><a href="https://wg21.link/cwg2251">2251</a></td>
     <td>C++17</td>
     <td>Unreachable enumeration list-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2252">
-    <td><a href="http://wg21.link/cwg2252">2252</a></td>
+    <td><a href="https://wg21.link/cwg2252">2252</a></td>
     <td>review</td>
     <td>Enumeration list-initialization from the same type</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2253">
-    <td><a href="http://wg21.link/cwg2253">2253</a></td>
+    <td><a href="https://wg21.link/cwg2253">2253</a></td>
     <td>DRWP</td>
     <td>Unnamed bit-fields and zero-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2254">
-    <td><a href="http://wg21.link/cwg2254">2254</a></td>
+    <td><a href="https://wg21.link/cwg2254">2254</a></td>
     <td>DRWP</td>
     <td>Standard-layout classes and bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2255">
-    <td><a href="http://wg21.link/cwg2255">2255</a></td>
+    <td><a href="https://wg21.link/cwg2255">2255</a></td>
     <td>DRWP</td>
     <td>Instantiated static data member templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2256">
-    <td><a href="http://wg21.link/cwg2256">2256</a></td>
+    <td><a href="https://wg21.link/cwg2256">2256</a></td>
     <td>DR</td>
     <td>Lifetime of trivially-destructible objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2257">
-    <td><a href="http://wg21.link/cwg2257">2257</a></td>
+    <td><a href="https://wg21.link/cwg2257">2257</a></td>
     <td>DR</td>
     <td>Lifetime extension of references vs exceptions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2258">
-    <td><a href="http://wg21.link/cwg2258">2258</a></td>
+    <td><a href="https://wg21.link/cwg2258">2258</a></td>
     <td>open</td>
     <td>Storage deallocation during period of destruction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2259">
-    <td><a href="http://wg21.link/cwg2259">2259</a></td>
+    <td><a href="https://wg21.link/cwg2259">2259</a></td>
     <td>C++17</td>
     <td>Unclear context describing ambiguity</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2260">
-    <td><a href="http://wg21.link/cwg2260">2260</a></td>
+    <td><a href="https://wg21.link/cwg2260">2260</a></td>
     <td>DRWP</td>
     <td>Explicit specializations of deleted member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2261">
-    <td><a href="http://wg21.link/cwg2261">2261</a></td>
+    <td><a href="https://wg21.link/cwg2261">2261</a></td>
     <td>extension</td>
     <td>Explicit instantiation of in-class <TT>friend</TT> definition</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2262">
-    <td><a href="http://wg21.link/cwg2262">2262</a></td>
+    <td><a href="https://wg21.link/cwg2262">2262</a></td>
     <td>C++17</td>
     <td>Attributes for <I>asm-definition</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2263">
-    <td><a href="http://wg21.link/cwg2263">2263</a></td>
+    <td><a href="https://wg21.link/cwg2263">2263</a></td>
     <td>drafting</td>
     <td>Default argument instantiation for <TT>friend</TT>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2264">
-    <td><a href="http://wg21.link/cwg2264">2264</a></td>
+    <td><a href="https://wg21.link/cwg2264">2264</a></td>
     <td>drafting</td>
     <td>Memberwise copying with indeterminate value</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2265">
-    <td><a href="http://wg21.link/cwg2265">2265</a></td>
+    <td><a href="https://wg21.link/cwg2265">2265</a></td>
     <td>drafting</td>
     <td>Delayed pack expansion and member redeclarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2266">
-    <td><a href="http://wg21.link/cwg2266">2266</a></td>
+    <td><a href="https://wg21.link/cwg2266">2266</a></td>
     <td>DR</td>
     <td>Has dependent type vs is type-dependent</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2267">
-    <td><a href="http://wg21.link/cwg2267">2267</a></td>
+    <td><a href="https://wg21.link/cwg2267">2267</a></td>
     <td>DR</td>
     <td>Copy-initialization of temporary in reference direct-initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2268">
-    <td><a href="http://wg21.link/cwg2268">2268</a></td>
+    <td><a href="https://wg21.link/cwg2268">2268</a></td>
     <td>C++17</td>
     <td>Unions with mutable members in constant expressions revisited</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2269">
-    <td><a href="http://wg21.link/cwg2269">2269</a></td>
+    <td><a href="https://wg21.link/cwg2269">2269</a></td>
     <td>dup</td>
     <td>Additional recursive references in aggregate DMIs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2270">
-    <td><a href="http://wg21.link/cwg2270">2270</a></td>
+    <td><a href="https://wg21.link/cwg2270">2270</a></td>
     <td>extension</td>
     <td>Non-inline functions and explicit instantiation declarations</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2271">
-    <td><a href="http://wg21.link/cwg2271">2271</a></td>
+    <td><a href="https://wg21.link/cwg2271">2271</a></td>
     <td>C++17</td>
     <td>Aliasing <TT>this</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2272">
-    <td><a href="http://wg21.link/cwg2272">2272</a></td>
+    <td><a href="https://wg21.link/cwg2272">2272</a></td>
     <td>C++17</td>
     <td>Implicit initialization of aggregate members of reference type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2273">
-    <td><a href="http://wg21.link/cwg2273">2273</a></td>
+    <td><a href="https://wg21.link/cwg2273">2273</a></td>
     <td>DRWP</td>
     <td>Inheriting constructors vs implicit default constructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2274">
-    <td><a href="http://wg21.link/cwg2274">2274</a></td>
+    <td><a href="https://wg21.link/cwg2274">2274</a></td>
     <td>NAD</td>
     <td>Generic lambda capture vs constexpr if</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2275">
-    <td><a href="http://wg21.link/cwg2275">2275</a></td>
+    <td><a href="https://wg21.link/cwg2275">2275</a></td>
     <td>drafting</td>
     <td>Type-dependence of function template</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2276">
-    <td><a href="http://wg21.link/cwg2276">2276</a></td>
+    <td><a href="https://wg21.link/cwg2276">2276</a></td>
     <td>C++17</td>
     <td>Dependent <TT>noexcept</TT> and function type-dependence</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2277">
-    <td><a href="http://wg21.link/cwg2277">2277</a></td>
+    <td><a href="https://wg21.link/cwg2277">2277</a></td>
     <td>DRWP</td>
     <td>Ambiguity inheriting constructors with default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2278">
-    <td><a href="http://wg21.link/cwg2278">2278</a></td>
+    <td><a href="https://wg21.link/cwg2278">2278</a></td>
     <td>DR</td>
     <td>Copy elision in constant expressions reconsidered</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2279">
-    <td><a href="http://wg21.link/cwg2279">2279</a></td>
+    <td><a href="https://wg21.link/cwg2279">2279</a></td>
     <td>NAD</td>
     <td>Multiple <I>attribute-specifier</I>s in one <I>attribute-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2280">
-    <td><a href="http://wg21.link/cwg2280">2280</a></td>
+    <td><a href="https://wg21.link/cwg2280">2280</a></td>
     <td>review</td>
     <td>Matching a usual deallocation function with placement new</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2281">
-    <td><a href="http://wg21.link/cwg2281">2281</a></td>
+    <td><a href="https://wg21.link/cwg2281">2281</a></td>
     <td>drafting</td>
     <td>Consistency of aligned <TT>operator delete</TT> replacement</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2282">
-    <td><a href="http://wg21.link/cwg2282">2282</a></td>
+    <td><a href="https://wg21.link/cwg2282">2282</a></td>
     <td>drafting</td>
     <td>Consistency with mismatched aligned/non-over-aligned allocation/deallocation functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2283">
-    <td><a href="http://wg21.link/cwg2283">2283</a></td>
+    <td><a href="https://wg21.link/cwg2283">2283</a></td>
     <td>drafting</td>
     <td>Missing complete type requirements</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2284">
-    <td><a href="http://wg21.link/cwg2284">2284</a></td>
+    <td><a href="https://wg21.link/cwg2284">2284</a></td>
     <td>open</td>
     <td>Sequencing of <I>braced-init-list</I> arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2285">
-    <td><a href="http://wg21.link/cwg2285">2285</a></td>
+    <td><a href="https://wg21.link/cwg2285">2285</a></td>
     <td>DRWP</td>
     <td>Issues with structured bindings</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2286">
-    <td><a href="http://wg21.link/cwg2286">2286</a></td>
+    <td><a href="https://wg21.link/cwg2286">2286</a></td>
     <td>NAD</td>
     <td>Assignment evaluation order</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2287">
-    <td><a href="http://wg21.link/cwg2287">2287</a></td>
+    <td><a href="https://wg21.link/cwg2287">2287</a></td>
     <td>DRWP</td>
     <td>Pointer-interconvertibility in non-standard-layout unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2288">
-    <td><a href="http://wg21.link/cwg2288">2288</a></td>
+    <td><a href="https://wg21.link/cwg2288">2288</a></td>
     <td>NAD</td>
     <td>Contradictory optionality in <I>simple-declaration</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2289">
-    <td><a href="http://wg21.link/cwg2289">2289</a></td>
+    <td><a href="https://wg21.link/cwg2289">2289</a></td>
     <td>DR</td>
     <td>Uniqueness of structured binding names</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2290">
-    <td><a href="http://wg21.link/cwg2290">2290</a></td>
+    <td><a href="https://wg21.link/cwg2290">2290</a></td>
     <td>DRWP</td>
     <td>Unclear specification for overload resolution and deleted special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2291">
-    <td><a href="http://wg21.link/cwg2291">2291</a></td>
+    <td><a href="https://wg21.link/cwg2291">2291</a></td>
     <td>dup</td>
     <td>Implicit conversion sequences in non-call contexts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2292">
-    <td><a href="http://wg21.link/cwg2292">2292</a></td>
+    <td><a href="https://wg21.link/cwg2292">2292</a></td>
     <td>DRWP</td>
     <td><I>simple-template-id</I> is ambiguous between <I>class-name</I> and <I>type-name</I></td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="2293">
-    <td><a href="http://wg21.link/cwg2293">2293</a></td>
+    <td><a href="https://wg21.link/cwg2293">2293</a></td>
     <td>DRWP</td>
     <td>Requirements for <I>simple-template-id</I> used as a <I>class-name</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2294">
-    <td><a href="http://wg21.link/cwg2294">2294</a></td>
+    <td><a href="https://wg21.link/cwg2294">2294</a></td>
     <td>DRWP</td>
     <td>Dependent <TT>auto</TT> static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2295">
-    <td><a href="http://wg21.link/cwg2295">2295</a></td>
+    <td><a href="https://wg21.link/cwg2295">2295</a></td>
     <td>extension</td>
     <td>Aggregates with deleted defaulted constructors</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="2296">
-    <td><a href="http://wg21.link/cwg2296">2296</a></td>
+    <td><a href="https://wg21.link/cwg2296">2296</a></td>
     <td>extension</td>
     <td>Are default argument instantiation failures in the &#8220;immediate context&#8221;?</td>
     <td align="center">Extension</td>
   </tr>
   <tr class="open" id="2297">
-    <td><a href="http://wg21.link/cwg2297">2297</a></td>
+    <td><a href="https://wg21.link/cwg2297">2297</a></td>
     <td>open</td>
     <td>Unclear specification of atomic operations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2298">
-    <td><a href="http://wg21.link/cwg2298">2298</a></td>
+    <td><a href="https://wg21.link/cwg2298">2298</a></td>
     <td>concurrency</td>
     <td>Actions and expression evaluation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2299">
-    <td><a href="http://wg21.link/cwg2299">2299</a></td>
+    <td><a href="https://wg21.link/cwg2299">2299</a></td>
     <td>DRWP</td>
     <td><TT>constexpr</TT> vararg functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2300">
-    <td><a href="http://wg21.link/cwg2300">2300</a></td>
+    <td><a href="https://wg21.link/cwg2300">2300</a></td>
     <td>tentatively ready</td>
     <td>Lambdas in multiple definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2301">
-    <td><a href="http://wg21.link/cwg2301">2301</a></td>
+    <td><a href="https://wg21.link/cwg2301">2301</a></td>
     <td>open</td>
     <td>Value-initialization and constexpr constructor evaluation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2302">
-    <td><a href="http://wg21.link/cwg2302">2302</a></td>
+    <td><a href="https://wg21.link/cwg2302">2302</a></td>
     <td>NAD</td>
     <td>Address comparison between different member subobjects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2303">
-    <td><a href="http://wg21.link/cwg2303">2303</a></td>
+    <td><a href="https://wg21.link/cwg2303">2303</a></td>
     <td>DR</td>
     <td>Partial ordering and recursive variadic inheritance</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2304">
-    <td><a href="http://wg21.link/cwg2304">2304</a></td>
+    <td><a href="https://wg21.link/cwg2304">2304</a></td>
     <td>NAD</td>
     <td>Incomplete type vs overload resolution</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2305">
-    <td><a href="http://wg21.link/cwg2305">2305</a></td>
+    <td><a href="https://wg21.link/cwg2305">2305</a></td>
     <td>DRWP</td>
     <td>Explicit instantiation of constexpr or inline variable template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2306">
-    <td><a href="http://wg21.link/cwg2306">2306</a></td>
+    <td><a href="https://wg21.link/cwg2306">2306</a></td>
     <td>NAD</td>
     <td>Nested friend templates of class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2307">
-    <td><a href="http://wg21.link/cwg2307">2307</a></td>
+    <td><a href="https://wg21.link/cwg2307">2307</a></td>
     <td>DRWP</td>
     <td>Unclear definition of &#8220;equivalent to a nontype template parameter&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2308">
-    <td><a href="http://wg21.link/cwg2308">2308</a></td>
+    <td><a href="https://wg21.link/cwg2308">2308</a></td>
     <td>NAD</td>
     <td>Structured bindings and lambda capture</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2309">
-    <td><a href="http://wg21.link/cwg2309">2309</a></td>
+    <td><a href="https://wg21.link/cwg2309">2309</a></td>
     <td>DR</td>
     <td>Restrictions on nested statements within <TT>constexpr</TT> functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2310">
-    <td><a href="http://wg21.link/cwg2310">2310</a></td>
+    <td><a href="https://wg21.link/cwg2310">2310</a></td>
     <td>DR</td>
     <td>Type completeness and derived-to-base pointer conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2311">
-    <td><a href="http://wg21.link/cwg2311">2311</a></td>
+    <td><a href="https://wg21.link/cwg2311">2311</a></td>
     <td>open</td>
     <td>Missed case for guaranteed copy elision</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2312">
-    <td><a href="http://wg21.link/cwg2312">2312</a></td>
+    <td><a href="https://wg21.link/cwg2312">2312</a></td>
     <td>drafting</td>
     <td>Structured bindings and <TT>mutable</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2313">
-    <td><a href="http://wg21.link/cwg2313">2313</a></td>
+    <td><a href="https://wg21.link/cwg2313">2313</a></td>
     <td>DRWP</td>
     <td>Redeclaration of structured binding reference variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2314">
-    <td><a href="http://wg21.link/cwg2314">2314</a></td>
+    <td><a href="https://wg21.link/cwg2314">2314</a></td>
     <td>dup</td>
     <td>Structured bindings and lambda capture</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2315">
-    <td><a href="http://wg21.link/cwg2315">2315</a></td>
+    <td><a href="https://wg21.link/cwg2315">2315</a></td>
     <td>DRWP</td>
     <td>What is the &#8220;corresponding special member&#8221; of a variant member?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2316">
-    <td><a href="http://wg21.link/cwg2316">2316</a></td>
+    <td><a href="https://wg21.link/cwg2316">2316</a></td>
     <td>drafting</td>
     <td>Simplifying class conversions in conditional expressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2317">
-    <td><a href="http://wg21.link/cwg2317">2317</a></td>
+    <td><a href="https://wg21.link/cwg2317">2317</a></td>
     <td>DR</td>
     <td>Self-referential default member initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2318">
-    <td><a href="http://wg21.link/cwg2318">2318</a></td>
+    <td><a href="https://wg21.link/cwg2318">2318</a></td>
     <td>DR</td>
     <td>Nondeduced contexts in deduction from a <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2319">
-    <td><a href="http://wg21.link/cwg2319">2319</a></td>
+    <td><a href="https://wg21.link/cwg2319">2319</a></td>
     <td>drafting</td>
     <td>Nested brace initialization from same type</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2320">
-    <td><a href="http://wg21.link/cwg2320">2320</a></td>
+    <td><a href="https://wg21.link/cwg2320">2320</a></td>
     <td>extension</td>
     <td><TT>constexpr if</TT> and boolean conversions</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2321">
-    <td><a href="http://wg21.link/cwg2321">2321</a></td>
+    <td><a href="https://wg21.link/cwg2321">2321</a></td>
     <td>DRWP</td>
     <td>Conditional operator and cv-qualified class prvalues</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2322">
-    <td><a href="http://wg21.link/cwg2322">2322</a></td>
+    <td><a href="https://wg21.link/cwg2322">2322</a></td>
     <td>DRWP</td>
     <td>Substitution failure and lexical order</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2323">
-    <td><a href="http://wg21.link/cwg2323">2323</a></td>
+    <td><a href="https://wg21.link/cwg2323">2323</a></td>
     <td>WP</td>
     <td>Expunge POD</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2324">
-    <td><a href="http://wg21.link/cwg2324">2324</a></td>
+    <td><a href="https://wg21.link/cwg2324">2324</a></td>
     <td>drafting</td>
     <td>Size of base class subobject</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2325">
-    <td><a href="http://wg21.link/cwg2325">2325</a></td>
+    <td><a href="https://wg21.link/cwg2325">2325</a></td>
     <td>drafting</td>
     <td><TT>std::launder</TT> and reuse of character buffers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2326">
-    <td><a href="http://wg21.link/cwg2326">2326</a></td>
+    <td><a href="https://wg21.link/cwg2326">2326</a></td>
     <td>dup</td>
     <td>Type deduction with initializer list containing ambiguous functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2327">
-    <td><a href="http://wg21.link/cwg2327">2327</a></td>
+    <td><a href="https://wg21.link/cwg2327">2327</a></td>
     <td>drafting</td>
     <td>Copy elision for direct-initialization with a conversion function</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2328">
-    <td><a href="http://wg21.link/cwg2328">2328</a></td>
+    <td><a href="https://wg21.link/cwg2328">2328</a></td>
     <td>drafting</td>
     <td>Unclear presentation style of template argument deduction rules</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2329">
-    <td><a href="http://wg21.link/cwg2329">2329</a></td>
+    <td><a href="https://wg21.link/cwg2329">2329</a></td>
     <td>drafting</td>
     <td>Virtual base classes and generated assignment operators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2330">
-    <td><a href="http://wg21.link/cwg2330">2330</a></td>
+    <td><a href="https://wg21.link/cwg2330">2330</a></td>
     <td>DR</td>
     <td>Missing references to variable templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2331">
-    <td><a href="http://wg21.link/cwg2331">2331</a></td>
+    <td><a href="https://wg21.link/cwg2331">2331</a></td>
     <td>drafting</td>
     <td>Redundancy in description of class scope</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2332">
-    <td><a href="http://wg21.link/cwg2332">2332</a></td>
+    <td><a href="https://wg21.link/cwg2332">2332</a></td>
     <td>DR</td>
     <td><I>template-name</I> as <I>simple-type-name</I> vs injected-class-name</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2333">
-    <td><a href="http://wg21.link/cwg2333">2333</a></td>
+    <td><a href="https://wg21.link/cwg2333">2333</a></td>
     <td>drafting</td>
     <td>Escape sequences in UTF-8 character literals</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2334">
-    <td><a href="http://wg21.link/cwg2334">2334</a></td>
+    <td><a href="https://wg21.link/cwg2334">2334</a></td>
     <td>open</td>
     <td>Creation of objects by <TT>typeid</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2335">
-    <td><a href="http://wg21.link/cwg2335">2335</a></td>
+    <td><a href="https://wg21.link/cwg2335">2335</a></td>
     <td>drafting</td>
     <td>Deduced return types vs member types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2336">
-    <td><a href="http://wg21.link/cwg2336">2336</a></td>
+    <td><a href="https://wg21.link/cwg2336">2336</a></td>
     <td>DR</td>
     <td>Destructor characteristics vs potentially-constructed subobjects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2337">
-    <td><a href="http://wg21.link/cwg2337">2337</a></td>
+    <td><a href="https://wg21.link/cwg2337">2337</a></td>
     <td>open</td>
     <td>Incorrect implication of logic ladder for conversion sequence tiebreakers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2338">
-    <td><a href="http://wg21.link/cwg2338">2338</a></td>
+    <td><a href="https://wg21.link/cwg2338">2338</a></td>
     <td>DRWP</td>
     <td>Undefined behavior converting to short enums with fixed underlying types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2339">
-    <td><a href="http://wg21.link/cwg2339">2339</a></td>
+    <td><a href="https://wg21.link/cwg2339">2339</a></td>
     <td>DRWP</td>
     <td>Underspecified template arguments in structured bindings</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2340">
-    <td><a href="http://wg21.link/cwg2340">2340</a></td>
+    <td><a href="https://wg21.link/cwg2340">2340</a></td>
     <td>open</td>
     <td>Reference collapsing and structured bindings</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2341">
-    <td><a href="http://wg21.link/cwg2341">2341</a></td>
+    <td><a href="https://wg21.link/cwg2341">2341</a></td>
     <td>extension</td>
     <td>Structured bindings with static storage duration</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2342">
-    <td><a href="http://wg21.link/cwg2342">2342</a></td>
+    <td><a href="https://wg21.link/cwg2342">2342</a></td>
     <td>DRWP</td>
     <td>Reference <TT>reinterpret_cast</TT> and pointer-interconvertibility</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2343">
-    <td><a href="http://wg21.link/cwg2343">2343</a></td>
+    <td><a href="https://wg21.link/cwg2343">2343</a></td>
     <td>extension</td>
     <td><TT>void*</TT> non-type template parameters</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2344">
-    <td><a href="http://wg21.link/cwg2344">2344</a></td>
+    <td><a href="https://wg21.link/cwg2344">2344</a></td>
     <td>NAD</td>
     <td>Redeclaration of names in <I>init-statement</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2345">
-    <td><a href="http://wg21.link/cwg2345">2345</a></td>
+    <td><a href="https://wg21.link/cwg2345">2345</a></td>
     <td>review</td>
     <td>Jumping across initializers in <I>init-statement</I>s and <I>condition</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2346">
-    <td><a href="http://wg21.link/cwg2346">2346</a></td>
+    <td><a href="https://wg21.link/cwg2346">2346</a></td>
     <td>DRWP</td>
     <td>Local variables in default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2347">
-    <td><a href="http://wg21.link/cwg2347">2347</a></td>
+    <td><a href="https://wg21.link/cwg2347">2347</a></td>
     <td>review</td>
     <td>Passing short scoped enumerations to ellipsis</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2348">
-    <td><a href="http://wg21.link/cwg2348">2348</a></td>
+    <td><a href="https://wg21.link/cwg2348">2348</a></td>
     <td>NAD</td>
     <td>Non-templated <TT>constexpr if</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2349">
-    <td><a href="http://wg21.link/cwg2349">2349</a></td>
+    <td><a href="https://wg21.link/cwg2349">2349</a></td>
     <td>NAD</td>
     <td>Class/enumeration names vs conditions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2350">
-    <td><a href="http://wg21.link/cwg2350">2350</a></td>
+    <td><a href="https://wg21.link/cwg2350">2350</a></td>
     <td>NAD</td>
     <td>Forwarding references and deduction guides</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2351">
-    <td><a href="http://wg21.link/cwg2351">2351</a></td>
+    <td><a href="https://wg21.link/cwg2351">2351</a></td>
     <td>DRWP</td>
     <td><TT>void{}</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2352">
-    <td><a href="http://wg21.link/cwg2352">2352</a></td>
+    <td><a href="https://wg21.link/cwg2352">2352</a></td>
     <td>DR</td>
     <td>Similar types and reference binding</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2353">
-    <td><a href="http://wg21.link/cwg2353">2353</a></td>
+    <td><a href="https://wg21.link/cwg2353">2353</a></td>
     <td>DR</td>
     <td>Potential results of a member access expression for a static data member</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="2354">
-    <td><a href="http://wg21.link/cwg2354">2354</a></td>
+    <td><a href="https://wg21.link/cwg2354">2354</a></td>
     <td>DR</td>
     <td>Extended alignment and object representation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2355">
-    <td><a href="http://wg21.link/cwg2355">2355</a></td>
+    <td><a href="https://wg21.link/cwg2355">2355</a></td>
     <td>extension</td>
     <td>Deducing <I>noexcept-specifier</I>s</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2356">
-    <td><a href="http://wg21.link/cwg2356">2356</a></td>
+    <td><a href="https://wg21.link/cwg2356">2356</a></td>
     <td>DRWP</td>
     <td>Base class copy and move constructors should not be inherited</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2357">
-    <td><a href="http://wg21.link/cwg2357">2357</a></td>
+    <td><a href="https://wg21.link/cwg2357">2357</a></td>
     <td>NAD</td>
     <td>Lookup in member function declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2358">
-    <td><a href="http://wg21.link/cwg2358">2358</a></td>
+    <td><a href="https://wg21.link/cwg2358">2358</a></td>
     <td>DR</td>
     <td>Explicit capture of value</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2359">
-    <td><a href="http://wg21.link/cwg2359">2359</a></td>
+    <td><a href="https://wg21.link/cwg2359">2359</a></td>
     <td>WP</td>
     <td>Unintended copy initialization with designated initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2360">
-    <td><a href="http://wg21.link/cwg2360">2360</a></td>
+    <td><a href="https://wg21.link/cwg2360">2360</a></td>
     <td>DR</td>
     <td><TT>[[maybe_unused]]</TT> and structured bindings</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2361">
-    <td><a href="http://wg21.link/cwg2361">2361</a></td>
+    <td><a href="https://wg21.link/cwg2361">2361</a></td>
     <td>open</td>
     <td>Unclear description of <TT>longjmp</TT> undefined behavior</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2362">
-    <td><a href="http://wg21.link/cwg2362">2362</a></td>
+    <td><a href="https://wg21.link/cwg2362">2362</a></td>
     <td>extension</td>
     <td><TT>__func__</TT> should be <TT>constexpr</TT></td>
     <td align="center">Extension</td>
   </tr>
   <tr id="2363">
-    <td><a href="http://wg21.link/cwg2363">2363</a></td>
+    <td><a href="https://wg21.link/cwg2363">2363</a></td>
     <td>NAD</td>
     <td>Opaque enumeration friend declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2364">
-    <td><a href="http://wg21.link/cwg2364">2364</a></td>
+    <td><a href="https://wg21.link/cwg2364">2364</a></td>
     <td>drafting</td>
     <td>Constant expressions, aggregate initialization, and modifications</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2365">
-    <td><a href="http://wg21.link/cwg2365">2365</a></td>
+    <td><a href="https://wg21.link/cwg2365">2365</a></td>
     <td>DR</td>
     <td>Confusing specification for <TT>dynamic_cast</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2366">
-    <td><a href="http://wg21.link/cwg2366">2366</a></td>
+    <td><a href="https://wg21.link/cwg2366">2366</a></td>
     <td>tentatively ready</td>
     <td>Can default initialization be constant initialization?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2367">
-    <td><a href="http://wg21.link/cwg2367">2367</a></td>
+    <td><a href="https://wg21.link/cwg2367">2367</a></td>
     <td>open</td>
     <td>Lambdas in default arguments vs the ODR</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2368">
-    <td><a href="http://wg21.link/cwg2368">2368</a></td>
+    <td><a href="https://wg21.link/cwg2368">2368</a></td>
     <td>DR</td>
     <td>Differences in relational and three-way constant comparisons</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2369">
-    <td><a href="http://wg21.link/cwg2369">2369</a></td>
+    <td><a href="https://wg21.link/cwg2369">2369</a></td>
     <td>drafting</td>
     <td>Ordering between constraints and substitution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2370">
-    <td><a href="http://wg21.link/cwg2370">2370</a></td>
+    <td><a href="https://wg21.link/cwg2370">2370</a></td>
     <td>drafting</td>
     <td><TT>friend</TT> declarations of namespace-scope functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2371">
-    <td><a href="http://wg21.link/cwg2371">2371</a></td>
+    <td><a href="https://wg21.link/cwg2371">2371</a></td>
     <td>open</td>
     <td>Use of the English term &#8220;attributes&#8221; is confusing</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2372">
-    <td><a href="http://wg21.link/cwg2372">2372</a></td>
+    <td><a href="https://wg21.link/cwg2372">2372</a></td>
     <td>DR</td>
     <td>Incorrect matching rules for block-scope <TT>extern</TT> declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2373">
-    <td><a href="http://wg21.link/cwg2373">2373</a></td>
+    <td><a href="https://wg21.link/cwg2373">2373</a></td>
     <td>DRWP</td>
     <td>Incorrect handling of static member function templates in partial ordering</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2374">
-    <td><a href="http://wg21.link/cwg2374">2374</a></td>
+    <td><a href="https://wg21.link/cwg2374">2374</a></td>
     <td>review</td>
     <td>Overly permissive specification of <TT>enum</TT> direct-list-initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2375">
-    <td><a href="http://wg21.link/cwg2375">2375</a></td>
+    <td><a href="https://wg21.link/cwg2375">2375</a></td>
     <td>NAD</td>
     <td>Multiple redeclarations of <TT>constexpr</TT> static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2376">
-    <td><a href="http://wg21.link/cwg2376">2376</a></td>
+    <td><a href="https://wg21.link/cwg2376">2376</a></td>
     <td>tentatively ready</td>
     <td>Class template argument deduction with array declarator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2377">
-    <td><a href="http://wg21.link/cwg2377">2377</a></td>
+    <td><a href="https://wg21.link/cwg2377">2377</a></td>
     <td>NAD</td>
     <td>Explicit copy constructor vs function viability</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2378">
-    <td><a href="http://wg21.link/cwg2378">2378</a></td>
+    <td><a href="https://wg21.link/cwg2378">2378</a></td>
     <td>drafting</td>
     <td>Inconsistent grammar for reference <I>init-capture</I> of pack</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2379">
-    <td><a href="http://wg21.link/cwg2379">2379</a></td>
+    <td><a href="https://wg21.link/cwg2379">2379</a></td>
     <td>DR</td>
     <td>Missing prohibition against <TT>constexpr</TT> in <TT>friend</TT> declaration</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2380">
-    <td><a href="http://wg21.link/cwg2380">2380</a></td>
+    <td><a href="https://wg21.link/cwg2380">2380</a></td>
     <td>DR</td>
     <td><I>capture-default</I> makes too many references odr-usable</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2381">
-    <td><a href="http://wg21.link/cwg2381">2381</a></td>
+    <td><a href="https://wg21.link/cwg2381">2381</a></td>
     <td>DR</td>
     <td>Composite pointer type of pointers to plain and noexcept member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2382">
-    <td><a href="http://wg21.link/cwg2382">2382</a></td>
+    <td><a href="https://wg21.link/cwg2382">2382</a></td>
     <td>review</td>
     <td>Array allocation overhead for non-allocating placement <TT>new</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2383">
-    <td><a href="http://wg21.link/cwg2383">2383</a></td>
+    <td><a href="https://wg21.link/cwg2383">2383</a></td>
     <td>NAD</td>
     <td>Variadic member functions of variadic class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2384">
-    <td><a href="http://wg21.link/cwg2384">2384</a></td>
+    <td><a href="https://wg21.link/cwg2384">2384</a></td>
     <td>DR</td>
     <td>Conversion function templates and qualification conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2385">
-    <td><a href="http://wg21.link/cwg2385">2385</a></td>
+    <td><a href="https://wg21.link/cwg2385">2385</a></td>
     <td>DR</td>
     <td>Lookup for <I>conversion-function-id</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2386">
-    <td><a href="http://wg21.link/cwg2386">2386</a></td>
+    <td><a href="https://wg21.link/cwg2386">2386</a></td>
     <td>DR</td>
     <td><T>tuple_size</T> requirements for structured binding</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="2387">
-    <td><a href="http://wg21.link/cwg2387">2387</a></td>
+    <td><a href="https://wg21.link/cwg2387">2387</a></td>
     <td>DR</td>
     <td>Linkage of const-qualified variable template</td>
     <td class="full" align="center">Clang 9</td>
   </tr>
   <tr id="2388">
-    <td><a href="http://wg21.link/cwg2388">2388</a></td>
+    <td><a href="https://wg21.link/cwg2388">2388</a></td>
     <td>NAD</td>
     <td>Applicability of <I>contract-attribute-specifier</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2389">
-    <td><a href="http://wg21.link/cwg2389">2389</a></td>
+    <td><a href="https://wg21.link/cwg2389">2389</a></td>
     <td>open</td>
     <td>Agreement of deduced and explicitly-specified variable types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2390">
-    <td><a href="http://wg21.link/cwg2390">2390</a></td>
+    <td><a href="https://wg21.link/cwg2390">2390</a></td>
     <td>tentatively ready</td>
     <td>Is the argument of <TT>__has_cpp_attribute</TT> macro-expanded?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2391">
-    <td><a href="http://wg21.link/cwg2391">2391</a></td>
+    <td><a href="https://wg21.link/cwg2391">2391</a></td>
     <td>DUP</td>
     <td>Additional template parameters following pack expansion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2392">
-    <td><a href="http://wg21.link/cwg2392">2392</a></td>
+    <td><a href="https://wg21.link/cwg2392">2392</a></td>
     <td>open</td>
     <td><I>new-expression</I> size check and constant evaluation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2393">
-    <td><a href="http://wg21.link/cwg2393">2393</a></td>
+    <td><a href="https://wg21.link/cwg2393">2393</a></td>
     <td>NAD</td>
     <td>Pseudo-destructors and object lifetime</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2394">
-    <td><a href="http://wg21.link/cwg2394">2394</a></td>
+    <td><a href="https://wg21.link/cwg2394">2394</a></td>
     <td>DR</td>
     <td>Const-default-constructible for members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2395">
-    <td><a href="http://wg21.link/cwg2395">2395</a></td>
+    <td><a href="https://wg21.link/cwg2395">2395</a></td>
     <td>open</td>
     <td>Parameters following a pack expansion</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2396">
-    <td><a href="http://wg21.link/cwg2396">2396</a></td>
+    <td><a href="https://wg21.link/cwg2396">2396</a></td>
     <td>open</td>
     <td>Lookup of names in complex <I>conversion-type-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2397">
-    <td><a href="http://wg21.link/cwg2397">2397</a></td>
+    <td><a href="https://wg21.link/cwg2397">2397</a></td>
     <td>drafting</td>
     <td><TT>auto</TT> specifier for pointers and references to arrays</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2398">
-    <td><a href="http://wg21.link/cwg2398">2398</a></td>
+    <td><a href="https://wg21.link/cwg2398">2398</a></td>
     <td>open</td>
     <td>Template template parameter matching and deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2399">
-    <td><a href="http://wg21.link/cwg2399">2399</a></td>
+    <td><a href="https://wg21.link/cwg2399">2399</a></td>
     <td>review</td>
     <td>Unclear referent of &#8220;expression&#8221; in <I>assignment-expression</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2400">
-    <td><a href="http://wg21.link/cwg2400">2400</a></td>
+    <td><a href="https://wg21.link/cwg2400">2400</a></td>
     <td>tentatively ready</td>
     <td>Constexpr virtual functions and temporary objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2401">
-    <td><a href="http://wg21.link/cwg2401">2401</a></td>
+    <td><a href="https://wg21.link/cwg2401">2401</a></td>
     <td>open</td>
     <td>Array decay vs prohibition of subobject non-type arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2402">
-    <td><a href="http://wg21.link/cwg2402">2402</a></td>
+    <td><a href="https://wg21.link/cwg2402">2402</a></td>
     <td>drafting</td>
     <td>When is the restriction to a single <I>c-char</I> in a Unicode literal enforced?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2403">
-    <td><a href="http://wg21.link/cwg2403">2403</a></td>
+    <td><a href="https://wg21.link/cwg2403">2403</a></td>
     <td>open</td>
     <td>Temporary materialization and base/member initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2404">
-    <td><a href="http://wg21.link/cwg2404">2404</a></td>
+    <td><a href="https://wg21.link/cwg2404">2404</a></td>
     <td>tentatively ready</td>
     <td><TT>[[no_unique_address]]</TT> and allocation order</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2405">
-    <td><a href="http://wg21.link/cwg2405">2405</a></td>
+    <td><a href="https://wg21.link/cwg2405">2405</a></td>
     <td>drafting</td>
     <td>Additional type-dependent expressions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2406">
-    <td><a href="http://wg21.link/cwg2406">2406</a></td>
+    <td><a href="https://wg21.link/cwg2406">2406</a></td>
     <td>tentatively ready</td>
     <td><TT>[[fallthrough]]</TT> attribute and iteration statements</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2407">
-    <td><a href="http://wg21.link/cwg2407">2407</a></td>
+    <td><a href="https://wg21.link/cwg2407">2407</a></td>
     <td>review</td>
     <td>Missing entry in Annex C for defaulted comparison operators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2408">
-    <td><a href="http://wg21.link/cwg2408">2408</a></td>
+    <td><a href="https://wg21.link/cwg2408">2408</a></td>
     <td>open</td>
     <td>Temporaries and previously-initialized elements in aggregate initialization</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2409">
-    <td><a href="http://wg21.link/cwg2409">2409</a></td>
+    <td><a href="https://wg21.link/cwg2409">2409</a></td>
     <td>drafting</td>
     <td>Explicit specializations of constexpr static data members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2410">
-    <td><a href="http://wg21.link/cwg2410">2410</a></td>
+    <td><a href="https://wg21.link/cwg2410">2410</a></td>
     <td>review</td>
     <td>Implicit calls of immediate functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2411">
-    <td><a href="http://wg21.link/cwg2411">2411</a></td>
+    <td><a href="https://wg21.link/cwg2411">2411</a></td>
     <td>open</td>
     <td>Comparison of pointers to members in template non-type arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2412">
-    <td><a href="http://wg21.link/cwg2412">2412</a></td>
+    <td><a href="https://wg21.link/cwg2412">2412</a></td>
     <td>open</td>
     <td>SFINAE vs undeduced placeholder type</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2413">
-    <td><a href="http://wg21.link/cwg2413">2413</a></td>
+    <td><a href="https://wg21.link/cwg2413">2413</a></td>
     <td>drafting</td>
     <td><TT>typename</TT> in <I>conversion-function-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2414">
-    <td><a href="http://wg21.link/cwg2414">2414</a></td>
+    <td><a href="https://wg21.link/cwg2414">2414</a></td>
     <td>drafting</td>
     <td>Unclear results if both member and friend <TT>operator&lt;=&gt;</TT> are declared</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2415">
-    <td><a href="http://wg21.link/cwg2415">2415</a></td>
+    <td><a href="https://wg21.link/cwg2415">2415</a></td>
     <td>NAD</td>
     <td><I>using-declaration</I>s vs copy assignment operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2416">
-    <td><a href="http://wg21.link/cwg2416">2416</a></td>
+    <td><a href="https://wg21.link/cwg2416">2416</a></td>
     <td>open</td>
     <td>Explicit specializations vs <TT>constexpr</TT> and <TT>consteval</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2417">
-    <td><a href="http://wg21.link/cwg2417">2417</a></td>
+    <td><a href="https://wg21.link/cwg2417">2417</a></td>
     <td>open</td>
     <td>Explicit instantiation and exception specifications</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2418">
-    <td><a href="http://wg21.link/cwg2418">2418</a></td>
+    <td><a href="https://wg21.link/cwg2418">2418</a></td>
     <td>tentatively ready</td>
     <td>Missing cases in definition of &#8220;usable in constant expressions&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="2419">
-    <td><a href="http://wg21.link/cwg2419">2419</a></td>
+    <td><a href="https://wg21.link/cwg2419">2419</a></td>
     <td>open</td>
     <td>Loss of generality treating pointers to objects as one-element arrays</td>
     <td align="center">Not resolved</td>
   </tr>
 </table>
 
 </div>
 </body>
 </html>

clang/www/cxx_status.html

 
 <p>Clang implements all of the ISO C++ 1998 standard
   (including the defects addressed in the ISO C++ 2003 standard)
   except for <tt>export</tt> (which was removed in C++11).
 
 <h2 id="cxx11">C++11 implementation status</h2>
 
 <p>Clang 3.3 and later implement all of the <a
-  href="http://www.iso.org/standard/50372.html">ISO
+  href="https://www.iso.org/standard/50372.html">ISO
   C++ 2011 standard</a>.
 
 <p>By default, Clang builds C++ code according to the C++98 standard, with many
 C++11 features accepted as extensions. You can use Clang in C++11 mode with the
 <code>-std=c++11</code> option. Clang's C++11 mode can be used
-with <a href="http://libcxx.llvm.org/">libc++</a> or with gcc's libstdc++.
+with <a href="https://libcxx.llvm.org/">libc++</a> or with gcc's libstdc++.
 
 <details>
 <summary>List of features and minimum Clang version with support</summary>
 
 <table width="689" border="1" cellspacing="0">
  <tr>
     <th>Language Feature</th>
     <th>C++11 Proposal</th>
     <th>Available in Clang?</th>
  </tr>
      <tr>
       <td rowspan="2">Rvalue references</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html">N2118</a></td>
+      <td><a href="https://wg21.link/n2118">N2118</a></td>
       <td class="full" align="center">Clang 2.9</td>
       <tr> <!-- from Kona 2019-->
-        <td><a href="http://wg21.link/p1825r0">P1825R0</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p1825r0">P1825R0</a> (<a href="#dr">DR</a>)</td>
         <td class="none" align="center">No</td>
       </tr>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;Rvalue references for <code>*this</code></td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm">N2439</a></td>
+      <td><a href="https://wg21.link/n2439">N2439</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Initialization of class objects by rvalues</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html">N1610</a></td>
+      <td><a href="https://wg21.link/n1610">N1610</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Non-static data member initializers</td>
-      <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm">N2756</a></td>
+      <td><a href="https://wg21.link/n2756">N2756</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Variadic templates</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf">N2242</a></td>
+      <td><a href="https://wg21.link/n2242">N2242</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;Extending variadic template template parameters</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf">N2555</a></td>
+      <td><a href="https://wg21.link/n2555">N2555</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td rowspan="2">Initializer lists</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm">N2672</a></td>
+      <td><a href="https://wg21.link/n2672">N2672</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
       <tr> <!-- from Kona 2019-->
-        <td><a href="http://wg21.link/p1009r2">P1009R2</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p1009r2">P1009R2</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 9</td>
       </tr>
     <tr>
       <td>Static assertions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html">N1720</a></td>
+      <td><a href="https://wg21.link/n1720">N1720</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td><code>auto</code>-typed variables</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf">N1984</a></td>
+      <td><a href="https://wg21.link/n1984">N1984</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;Multi-declarator <code>auto</code></td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf">N1737</a></td>
+      <td><a href="https://wg21.link/n1737">N1737</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;Removal of auto as a storage-class specifier</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm">N2546</a></td>
+      <td><a href="https://wg21.link/n2546">N2546</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;New function declarator syntax</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm">N2541</a></td>
+      <td><a href="https://wg21.link/n2541">N2541</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td rowspan="2">Lambda expressions</td>
-      <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf">N2927</a></td>
+      <td><a href="https://wg21.link/n2927">N2927</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
       <tr>
         <!-- from Albuquerque 2017 -->
-        <td><a href="http://wg21.link/p0588r1">P0588R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0588r1">P0588R1</a> (<a href="#dr">DR</a>)</td>
         <td class="none" align="center">No</td>
       </tr>
     <tr>
       <td>Declared type of an expression</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf">N2343</a></td>
+      <td><a href="https://wg21.link/n2343">N2343</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;Incomplete return types</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf">N3276</a></td>
+      <td><a href="https://wg21.link/n3276">N3276</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Right angle brackets</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html">N1757</a></td>
+      <td><a href="https://wg21.link/n1757">N1757</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Default template arguments for function templates</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226">DR226</a></td>
+      <td><a href="https://wg21.link/cwg226">DR226</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Solving the SFINAE problem for expressions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html">DR339</a></td>
+      <td><a href="https://wg21.link/n2634">DR339</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Alias templates</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf">N2258</a></td>
+      <td><a href="https://wg21.link/n2258">N2258</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Extern templates</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm">N1987</a></td>
+      <td><a href="https://wg21.link/n1987">N1987</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Null pointer constant</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf">N2431</a></td>
+      <td><a href="https://wg21.link/n2431">N2431</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Strongly-typed enums</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf">N2347</a></td>
+      <td><a href="https://wg21.link/n2347">N2347</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Forward declarations for enums</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf">N2764</a>
-      <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1206">DR1206</a></td>
+      <td><a href="https://wg21.link/n2764">N2764</a>
+      <br><a href="https://wg21.link/cwg1206">DR1206</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Standardized attribute syntax</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf">N2761</a></td>
+      <td><a href="https://wg21.link/n2761">N2761</a></td>
       <td class="full" align="center">Clang 3.3 <a href="#n2761">(1)</a></td>
     </tr>
     <tr>
       <td rowspan="2">Generalized constant expressions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf">N2235</a></td>
+      <td><a href="https://wg21.link/n2235">N2235</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
       <tr>
         <!-- from Albuquerque 2017 -->
-        <td><a href="http://wg21.link/p0859r0">P0859R0</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0859r0">P0859R0</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 8</td>
       </tr>
     <tr>
       <td>Alignment support</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf">N2341</a></td>
+      <td><a href="https://wg21.link/n2341">N2341</a></td>
       <td class="full" align="center">Clang 3.3</td>
     </tr>
     <tr>
       <td>Conditionally-support behavior</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1627.pdf">N1627</a></td>
+      <td><a href="https://wg21.link/n1627">N1627</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Changing undefined behavior into diagnosable errors</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1727.pdf">N1727</a></td>
+      <td><a href="https://wg21.link/n1727">N1727</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Delegating constructors</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf">N1986</a></td>
+      <td><a href="https://wg21.link/n1986">N1986</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td rowspan="2">Inheriting constructors</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm">N2540</a></td>
+      <td><a href="https://wg21.link/n2540">N2540</a></td>
       <td class="full" align="center">Clang 3.3</td>
     </tr>
       <tr>
         <!-- from Kona 2015 -->
-        <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0136r1.html">P0136R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0136r1">P0136R1</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 3.9</td>
       </tr>
     <tr>
       <td>Explicit conversion operators</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf">N2437</a></td>
+      <td><a href="https://wg21.link/n2437">N2437</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>New character types</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html">N2249</a></td>
+      <td><a href="https://wg21.link/n2249">N2249</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Unicode string literals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm">N2442</a></td>
+      <td><a href="https://wg21.link/n2442">N2442</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Raw string literals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm">N2442</a></td>
+      <td><a href="https://wg21.link/n2442">N2442</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Universal character names in literals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html">N2170</a></td>
+      <td><a href="https://wg21.link/n2170">N2170</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>User-defined literals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf">N2765</a></td>
+      <td><a href="https://wg21.link/n2765">N2765</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Standard Layout Types</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm">N2342</a></td>
+      <td><a href="https://wg21.link/n2342">N2342</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td rowspan="2">Defaulted functions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm">N2346</a></td>
+      <td><a href="https://wg21.link/n2346">N2346</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
       <tr> <!-- from Kona 2019-->
-        <td><a href="http://wg21.link/p1286r2">P1286R2</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p1286r2">P1286R2</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 9</td>
       </tr>
     <tr>
       <td>Deleted functions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm">N2346</a></td>
+      <td><a href="https://wg21.link/n2346">N2346</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Extended friend declarations</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf">N1791</a></td>
+      <td><a href="https://wg21.link/n1791">N1791</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Extending <code>sizeof</code></td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html">N2253</a>
-      <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#850">DR850</a></td>
+      <td><a href="https://wg21.link/n2253">N2253</a>
+      <br><a href="https://wg21.link/cwg850">DR850</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Inline namespaces</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm">N2535</a></td>
+      <td><a href="https://wg21.link/n2535">N2535</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Unrestricted unions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf">N2544</a></td>
+      <td><a href="https://wg21.link/n2544">N2544</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Local and unnamed types as template arguments</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm">N2657</a></td>
+      <td><a href="https://wg21.link/n2657">N2657</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td rowspan="2">Range-based for</td>
-      <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html">N2930</a></td>
+      <td><a href="https://wg21.link/n2930">N2930</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
       <tr>
         <!-- from Jacksonville 2018 -->
-        <td><a href="http://wg21.link/p0962r1">P0962R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0962r1">P0962R1</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 8</td>
       </tr>
     <tr>
       <td>Explicit virtual overrides</td>
-      <td><a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm">N2928</a>
-      <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm">N3206</a>
-      <br><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm">N3272</a></td>
+      <td><a href="https://wg21.link/n2928">N2928</a>
+      <br><a href="https://wg21.link/n3206">N3206</a>
+      <br><a href="https://wg21.link/n3272">N3272</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Minimal support for garbage collection and reachability-based leak detection</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm">N2670</a></td>
+      <td><a href="https://wg21.link/n2670">N2670</a></td>
       <td class="na" align="center">N/A <a href="#n2670">(2)</a></td>
     </tr>
     <tr>
       <td>Allowing move constructors to throw [noexcept]</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html">N3050</a></td>
+      <td><a href="https://wg21.link/n3050">N3050</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
     <tr>
       <td>Defining move special member functions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html">N3053</a></td>
+      <td><a href="https://wg21.link/n3053">N3053</a></td>
       <td class="full" align="center">Clang 3.0</td>
     </tr>
 
     <tr class="separator">
       <th align="center" colspan="3">Concurrency</th>
     </tr>
     <tr>
       <td>Sequence points</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html">N2239</a></td>
+      <td><a href="https://wg21.link/n2239">N2239</a></td>
       <td class="full" align="center">Clang 3.3</td>
     </tr>
     <tr>
       <td>Atomic operations</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html">N2427</a></td>
+      <td><a href="https://wg21.link/n2427">N2427</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Strong Compare and Exchange</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2748.html">N2748</a></td>
+      <td><a href="https://wg21.link/n2748">N2748</a></td>
       <td class="full" align="center">Clang 3.1 <a href="#n2748">(3)</a></td>
     </tr>
     <tr>
       <td>Bidirectional Fences</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm">N2752</a></td>
+      <td><a href="https://wg21.link/n2752">N2752</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
 
     <tr>
       <td>Memory model</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm">N2429</a></td>
+      <td><a href="https://wg21.link/n2429">N2429</a></td>
       <td class="full" align="center">Clang 3.2</td>
     </tr>
     <tr>
       <td>Data-dependency ordering: atomics and memory model</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm">N2664</a></td>
+      <td><a href="https://wg21.link/n2664">N2664</a></td>
       <td class="full" align="center">Clang 3.2 <a href="#n2664">(4)</a></td>
     </tr>
     <tr>
       <td>Propagating exceptions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html">N2179</a></td>
+      <td><a href="https://wg21.link/n2179">N2179</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Allow atomics use in signal handlers</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm">N2547</a></td>
+      <td><a href="https://wg21.link/n2547">N2547</a></td>
       <td class="full" align="center">Clang 3.1</td>
     </tr>
     <tr>
       <td>Thread-local storage</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm">N2659</a></td>
+      <td><a href="https://wg21.link/n2659">N2659</a></td>
       <td class="full" align="center">Clang 3.3 <a href="#n2659">(5)</a></td>
     </tr>
     <tr>
       <td>Dynamic initialization and destruction with concurrency</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm">N2660</a></td>
+      <td><a href="https://wg21.link/n2660">N2660</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
 
     <tr class="separator">
       <th align="center" colspan="3">C99 Features in C++11</th>
     </tr>
     <tr>
       <td><code>__func__</code> predefined identifier</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm">N2340</a></td>
+      <td><a href="https://wg21.link/n2340">N2340</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>C99 preprocessor</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm">N1653</a></td>
+      <td><a href="https://wg21.link/n1653">N1653</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td><code>long long</code></td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf">N1811</a></td>
+      <td><a href="https://wg21.link/n1811">N1811</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>Extended integral types</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf">N1988</a></td>
+      <td><a href="https://wg21.link/n1988">N1988</a></td>
       <td class="na" align="center">N/A <a href="#n1988">(6)</a></td>
     </tr>
 </table>
 
 <p>
 <span id="n2761">(1): The <code>[[carries_dependency]]</code> attribute
 has no effect.</span><br>
 <span id="n2670">(2): No compiler changes are required for an implementation
 such as Clang that does not provide garbage collection.</span><br>
 <span id="n2748">(3): All compare-exchange operations are emitted as
 strong compare-exchanges.</span><br>
 <span id="n2664">(4): <code>memory_order_consume</code> is lowered to
 <code>memory_order_acquire</code>.</span><br>
 <span id="n2659">(5): <code>thread_local</code> support
 requires a C++ runtime library providing <code>__cxa_thread_atexit</code>, such
-as <a href="http://libcxxabi.llvm.org">libc++abi</a> 3.6 or later,
+as <a href="https://libcxxabi.llvm.org">libc++abi</a> 3.6 or later,
 or libsupc++ 4.8 or later.</span><br>
 <span id="n1988">(6): No compiler changes are required for an implementation
 such as Clang that does not provide any extended integer types.
 <code>__int128</code> is not treated as an extended integer type,
 because changing <code>intmax_t</code> would be an ABI-incompatible
 change.</span>
 </p>
 </details>
 
 <h2 id="cxx14">C++14 implementation status</h2>
 
 <p>Clang 3.4 and later implement all of the <a
-    href="http://www.iso.org/standard/64029.html">ISO
+    href="https://www.iso.org/standard/64029.html">ISO
     C++ 2014 standard</a>.
 
 <p>You can use Clang in C++14 mode with the <code>-std=c++14</code> option
 (use <code>-std=c++1y</code> in Clang 3.4 and earlier).</p>
 
 <details>
 <summary>List of features and minimum Clang version with support</summary>
 
 <table width="689" border="1" cellspacing="0">
  <tr>
     <th>Language Feature</th>
     <th>C++14 Proposal</th>
     <th>Available in Clang?</th>
  </tr>
     <tr>
       <td>Tweak to certain C++ contextual conversions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3323.pdf">N3323</a></td>
+      <td><a href="https://wg21.link/n3323">N3323</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Binary literals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf">N3472</a></td>
+      <td><a href="https://wg21.link/n3472">N3472</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
       <td>decltype(auto)</td>
-      <td rowspan=2 style="vertical-align:middle"><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3638.html">N3638</a></td>
+      <td rowspan=2 style="vertical-align:middle"><a href="https://wg21.link/n3638">N3638</a></td>
       <td class="full" align="center">Clang 3.3</td>
     </tr>
     <tr>
       <td>Return type deduction for normal functions</td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Initialized lambda captures</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3648.html">N3648</a></td>
+      <td><a href="https://wg21.link/n3648">N3648</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Generic lambdas</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3649.html">N3649</a></td>
+      <td><a href="https://wg21.link/n3649">N3649</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Variable templates</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3651.pdf">N3651</a></td>
+      <td><a href="https://wg21.link/n3651">N3651</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Relaxing requirements on constexpr functions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html">N3652</a></td>
+      <td><a href="https://wg21.link/n3652">N3652</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Member initializers and aggregates</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3653.html">N3653</a></td>
+      <td><a href="https://wg21.link/n3653">N3653</a></td>
       <td class="full" align="center">Clang 3.3</td>
     </tr>
     <tr>
       <td>Clarifying memory allocation</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3664.html">N3664</a></td>
+      <td><a href="https://wg21.link/n3664">N3664</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td><tt>[[deprecated]]</tt> attribute</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3760.html">N3760</a></td>
+      <td><a href="https://wg21.link/n3760">N3760</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>Single quotation mark as digit separator</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3781.pdf">N3781</a></td>
+      <td><a href="https://wg21.link/n3781">N3781</a></td>
       <td class="full" align="center">Clang 3.4</td>
     </tr>
     <tr>
       <td>C++ Sized Deallocation</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3778.html">N3778</a></td>
+      <td><a href="https://wg21.link/n3778">N3778</a></td>
       <td class="full" align="center">Clang 3.4 <a href="#n3778">(7)</a></td>
     </tr>
 </table>
 
 <p>
 <span id="n3778">(7): In Clang 3.7 and later, sized deallocation is only enabled
 if the user passes the <code>-fsized-deallocation</code> flag. The user must
 supply definitions of the sized deallocation functions, either by providing them

  <tr>
     <th>Language Feature</th>
     <th>C++17 Proposal</th>
     <th>Available in Clang?</th>
  </tr>
     <!-- Issaquah 2014 papers -->
     <tr>
       <td><tt>static_assert</tt> with no message</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3928.pdf">N3928</a></td>
+      <td><a href="https://wg21.link/n3928">N3928</a></td>
       <td class="full" align="center">Clang 3.5</td>
     </tr>
     <!-- Rapperswil papers -->
     <tr>
       <td>Disabling trigraph expansion by default</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4086.html">N4086</a></td>
+      <td><a href="https://wg21.link/n4086">N4086</a></td>
       <td class="full" align="center">Clang 3.5</td>
     </tr>
     <!--
     <tr>
       <td rowspan="2">Terse range-based for loops (removed from C++17)</td>
-      <td rowspan="2"><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3994.htm">N3994</a></td>
+      <td rowspan="2"><a href="https://wg21.link/n3994">N3994</a></td>
       <td class="none" align="center">Clang 3.5: Yes</td>
     </tr>
     <tr>
       <td class="svn" align="center">SVN: No</td>
     </tr>
     -->
     <tr>
       <td><tt>typename</tt> in a template template parameter</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4051.html">N4051</a></td>
+      <td><a href="https://wg21.link/n4051">N4051</a></td>
       <td class="full" align="center">Clang 3.5</td>
     </tr>
     <tr>
       <td>New <tt>auto</tt> rules for direct-list-initialization
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3922.html">N3922</a></td>
+      <td><a href="https://wg21.link/n3922">N3922</a></td>
       <td class="full" align="center">Clang 3.8 <a href="#n3922">(8)</a></td>
     </tr>
     <!-- Urbana papers -->
     <tr>
       <td rowspan="2">Fold expressions</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4295.html">N4295</a></td>
+      <td><a href="https://wg21.link/n4295">N4295</a></td>
       <td class="full" align="center">Clang 3.6</td>
     </tr>
       <tr> <!-- from Jacksonville -->
-        <td><a href="http://wg21.link/p0036r0">P0036R0</a></td>
+        <td><a href="https://wg21.link/p0036r0">P0036R0</a></td>
         <td class="full" align="center">Clang 3.9</td>
       </tr>
     <tr>
       <td><tt>u8</tt> character literals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4267.html">N4267</a></td>
+      <td><a href="https://wg21.link/n4267">N4267</a></td>
       <td class="full" align="center">Clang 3.6</td>
     </tr>
     <tr>
       <td>Nested namespace definition</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4230.html">N4230</a></td>
+      <td><a href="https://wg21.link/n4230">N4230</a></td>
       <td class="full" align="center">Clang 3.6</td>
     </tr>
     <tr>
       <td>Attributes for namespaces and enumerators</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4266.html">N4266</a></td>
+      <td><a href="https://wg21.link/n4266">N4266</a></td>
       <td class="full" align="center">Clang 3.6</td>
     </tr>
     <tr>
       <td>Allow constant evaluation for all non-type template arguments</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4268.html">N4268</a></td>
+      <td><a href="https://wg21.link/n4268">N4268</a></td>
       <td class="full" align="center">Clang 3.6</td>
     </tr>
     <!-- Kona papers -->
     <tr>
       <td>Remove deprecated <tt>register</tt> storage class</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0001r1.html">P0001R1</a></td>
+      <td><a href="https://wg21.link/p0001r1">P0001R1</a></td>
       <td class="full" align="center">Clang 3.8</td>
     </tr>
     <tr>
       <td>Remove deprecated <tt>bool</tt> increment</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0002r1.html">P0002R1</a></td>
+      <td><a href="https://wg21.link/p0002r1">P0002R1</a></td>
       <td class="full" align="center">Clang 3.8</td>
     </tr>
     <tr>
       <td>Make exception specifications part of the type system</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0012r1.html">P0012R1</a></td>
+      <td><a href="https://wg21.link/p0012r1">P0012R1</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
     <tr>
       <td><tt>__has_include</tt> in preprocessor conditionals</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0061.html">P0061R1</a></td>
+      <td><a href="https://wg21.link/p0061r1">P0061R1</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
     <!-- Jacksonville papers -->
     <tr>
       <td><tt>[[fallthrough]]</tt> attribute</td>
-      <td><a href="http://wg21.link/p0188r1">P0188R1</a></td>
+      <td><a href="https://wg21.link/p0188r1">P0188R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td rowspan="2"><tt>[[nodiscard]]</tt> attribute</td>
-      <td><a href="http://wg21.link/p0189r1">P0189R1</a></td>
+      <td><a href="https://wg21.link/p0189r1">P0189R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
       <tr> <!-- from Cologne 2019 -->
-        <td><a href="http://wg21.link/p1771r1">P1771R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p1771r1">P1771R1</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 9</td>
       </tr>
     <tr>
       <td><tt>[[maybe_unused]]</tt> attribute</td>
-      <td><a href="http://wg21.link/p0212r1">P0212R1</a></td>
+      <td><a href="https://wg21.link/p0212r1">P0212R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Aggregate initialization of classes with base classes</td>
-      <td><a href="http://wg21.link/p0017r1">P0017R1</a></td>
+      <td><a href="https://wg21.link/p0017r1">P0017R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td><tt>constexpr</tt> lambda expressions</td>
-      <td><a href="http://wg21.link/p0170r1">P0170R1</a></td>
+      <td><a href="https://wg21.link/p0170r1">P0170R1</a></td>
       <td class="full" align="center">Clang 5</td>
     </tr>
     <tr>
       <td>Differing <tt>begin</tt> and <tt>end</tt> types in range-based <tt>for</tt></td>
-      <td><a href="http://wg21.link/p0184r0">P0184R0</a></td>
+      <td><a href="https://wg21.link/p0184r0">P0184R0</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Lambda capture of <tt>*this</tt></td>
-      <td><a href="http://wg21.link/p0018r3">P0018R3</a></td>
+      <td><a href="https://wg21.link/p0018r3">P0018R3</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Direct-list-initialization of <tt>enum</tt>s</td>
-      <td><a href="http://wg21.link/p0138r2">P0138R2</a></td>
+      <td><a href="https://wg21.link/p0138r2">P0138R2</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Hexadecimal floating-point literals</td>
-      <td><a href="http://wg21.link/p0245r1">P0245R1</a></td>
+      <td><a href="https://wg21.link/p0245r1">P0245R1</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
     <!-- Oulu papers -->
     <tr>
       <td>Using attribute namespaces without repetition</td>
-      <td><a href="http://wg21.link/p0028r4">P0028R4</a></td>
+      <td><a href="https://wg21.link/p0028r4">P0028R4</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Dynamic memory allocation for over-aligned data</td>
-      <td><a href="http://wg21.link/p0035r4">P0035R4</a></td>
+      <td><a href="https://wg21.link/p0035r4">P0035R4</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
     <tr>
       <td rowspan="4">Template argument deduction for class templates</td>
-      <td><a href="http://wg21.link/p0091r3">P0091R3</a></td>
+      <td><a href="https://wg21.link/p0091r3">P0091R3</a></td>
       <td rowspan="2" class="full" align="center">Clang 5</td>
     </tr>
       <tr> <!-- from Issaquah -->
-        <td><a href="http://wg21.link/p0512r0">P0512R0</a></td>
+        <td><a href="https://wg21.link/p0512r0">P0512R0</a></td>
       </tr>
       <tr>
         <!-- from Kona 2017 -->
-        <td><a href="http://wg21.link/p0620r1">P0620R0</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0620r1">P0620R0</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 7</td>
       </tr>
       <tr>
         <!-- from Toronto 2017 -->
-        <td><a href="http://wg21.link/p0702r1">P0702R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0702r1">P0702R1</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 6</td>
       </tr>
     <tr>
       <td>Non-type template parameters with <tt>auto</tt> type</td>
-      <td><a href="http://wg21.link/p0127r2">P0127R2</a></td>
+      <td><a href="https://wg21.link/p0127r2">P0127R2</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
     <tr>
       <td>Guaranteed copy elision</td>
-      <td><a href="http://wg21.link/p0135r1">P0135R1</a></td>
+      <td><a href="https://wg21.link/p0135r1">P0135R1</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
     <tr>
       <td rowspan=2>Stricter expression evaluation order</td>
-      <td><a href="http://wg21.link/p0145r3">P0145R3</a></td>
+      <td><a href="https://wg21.link/p0145r3">P0145R3</a></td>
       <td class="full" align="center" rowspan=2>Clang 4 <a href="#p0145">(9)</a></td>
     </tr>
     <tr>
-      <td><a href="http://wg21.link/p0400r0">P0400R0</a></td>
+      <td><a href="https://wg21.link/p0400r0">P0400R0</a></td>
     </tr>
     <tr>
       <td>Requirement to ignore unknown attributes</td>
-      <td><a href="http://wg21.link/p0283r2">P0283R2</a></td>
+      <td><a href="https://wg21.link/p0283r2">P0283R2</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
     <tr>
       <td><tt>constexpr</tt> <em>if-statement</em>s</td>
-      <td><a href="http://wg21.link/p0292r2">P0292R2</a></td>
+      <td><a href="https://wg21.link/p0292r2">P0292R2</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Inline variables</td>
-      <td><a href="http://wg21.link/p0386r2">P0386R2</a></td>
+      <td><a href="https://wg21.link/p0386r2">P0386R2</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td rowspan="3">Structured bindings</td>
-      <td><a href="http://wg21.link/p0217r3">P0217R3</a></td>
+      <td><a href="https://wg21.link/p0217r3">P0217R3</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
       <tr>
         <!-- from Jacksonville 2018 -->
-        <td><a href="http://wg21.link/p0961r1">P0961R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0961r1">P0961R1</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 8</td>
       </tr>
       <tr>
         <!-- from Jacksonville 2018 -->
-        <td><a href="http://wg21.link/p0969r0">P0969R0</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p0969r0">P0969R0</a> (<a href="#dr">DR</a>)</td>
         <td class="full" align="center">Clang 8</td>
       </tr>
     <tr>
       <td>Separate variable and condition for <tt>if</tt> and <tt>switch</tt></td>
-      <td><a href="http://wg21.link/p0305r1">P0305R1</a></td>
+      <td><a href="https://wg21.link/p0305r1">P0305R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <!-- Issaquah 2016 papers -->
     <tr>
       <td>Matching template template parameters to compatible arguments</td>
-      <td><a href="http://wg21.link/p0522r0">P0522R0</a></td>
+      <td><a href="https://wg21.link/p0522r0">P0522R0</a></td>
       <td class="partial" align="center">Partial <a href="#p0522">(10)</a></td>
     </tr>
     <tr>
       <td>Removing deprecated dynamic exception specifications</td>
-      <td><a href="http://wg21.link/p0003r5">P0003R5</a></td>
+      <td><a href="https://wg21.link/p0003r5">P0003R5</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
     <tr>
       <td>Pack expansions in <em>using-declarations</em></td>
-      <td><a href="http://wg21.link/p0195r2">P0195R2</a></td>
+      <td><a href="https://wg21.link/p0195r2">P0195R2</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
 </table>
 
 <p>
 <span id="n3922">(8): This is a backwards-incompatible change that is applied to
 all language versions that allow type deduction from <tt>auto</tt>
 (per the request of the C++ committee).

  <tr>
     <th>Language Feature</th>
     <th>C++2a Proposal</th>
     <th>Available in Clang?</th>
  </tr>
     <!-- Toronto 2017 papers -->
     <tr>
       <td>Default member initializers for bit-fields</td>
-      <td><a href="http://wg21.link/p0683r1">P0683R1</a></td>
+      <td><a href="https://wg21.link/p0683r1">P0683R1</a></td>
       <td class="full" align="center">Clang 6</td>
     </tr>
     <tr>
       <td><tt>const&amp;</tt>-qualified pointers to members</td>
-      <td><a href="http://wg21.link/p0704r1">P0704R1</a></td>
+      <td><a href="https://wg21.link/p0704r1">P0704R1</a></td>
       <td class="full" align="center">Clang 6</td>
     </tr>
     <tr>
       <td>Allow <i>lambda-capture</i> <tt>[=, this]</tt></td>
-      <td><a href="http://wg21.link/p0409r2">P0409R2</a></td>
+      <td><a href="https://wg21.link/p0409r2">P0409R2</a></td>
       <td class="full" align="center">Clang 6</td>
     </tr>
     <tr>
       <td rowspan="2"><tt>__VA_OPT__</tt> for preprocessor comma elision</td>
-      <td><a href="http://wg21.link/p0306r4">P0306R4</a></td>
+      <td><a href="https://wg21.link/p0306r4">P0306R4</a></td>
       <td class="full" align="center">Clang 6</td>
     </tr>
       <tr> <!-- from Rapperswil -->
-        <td><a href="http://wg21.link/p1042r1">P1042R1</a></td>
+        <td><a href="https://wg21.link/p1042r1">P1042R1</a></td>
         <td class="full" align="center">Clang 9</td>
       </tr>
     <tr>
       <td>Designated initializers</td>
-      <td><a href="http://wg21.link/p0329r4">P0329R4</a></td>
+      <td><a href="https://wg21.link/p0329r4">P0329R4</a></td>
       <td class="svn" align="center">SVN</td>
     </tr>
     <tr>
       <td><i>template-parameter-list</i> for generic lambdas</td>
-      <td><a href="http://wg21.link/p0428r2">P0428R2</a></td>
+      <td><a href="https://wg21.link/p0428r2">P0428R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr id="p0734">
       <td rowspan="7">Concepts</td>
-      <td><a href="http://wg21.link/p0734r0">P0734R0</a></td>
+      <td><a href="https://wg21.link/p0734r0">P0734R0</a></td>
       <td rowspan="7" class="none" align="center">No</td>
     </tr>
       <tr> <!-- from Albuquerque -->
-        <td><a href="http://wg21.link/p0857r0">P0857R0</a></td>
+        <td><a href="https://wg21.link/p0857r0">P0857R0</a></td>
       </tr>
       <tr> <!-- from San Diego -->
-        <td><a href="http://wg21.link/p1084r2">P1084R2</a></td>
+        <td><a href="https://wg21.link/p1084r2">P1084R2</a></td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1141r2">P1414R2</a></td>
+        <td><a href="https://wg21.link/p1141r2">P1414R2</a></td>
       </tr>
       <tr> <!-- from Cologne -->
-        <td><a href="http://wg21.link/p0848r3">P0848R3</a></td>
+        <td><a href="https://wg21.link/p0848r3">P0848R3</a></td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1616r1">P1616R1</a></td>
+        <td><a href="https://wg21.link/p1616r1">P1616R1</a></td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1452r2">P1452R2</a></td>
+        <td><a href="https://wg21.link/p1452r2">P1452R2</a></td>
       </tr>
     <!-- Albuquerque papers -->
     <tr>
       <td>Range-based for statements with initializer</td>
-      <td><a href="http://wg21.link/p0614r1">P0614R1</a></td>
+      <td><a href="https://wg21.link/p0614r1">P0614R1</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td>ADL and function templates that are not visible</td>
-      <td><a href="http://wg21.link/p0846r0">P0846R0</a></td>
+      <td><a href="https://wg21.link/p0846r0">P0846R0</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>
       <td><tt>const</tt> mismatch with defaulted copy constructor</td>
-      <td><a href="http://wg21.link/p0641r2">P0641R2</a></td>
+      <td><a href="https://wg21.link/p0641r2">P0641R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td rowspan="6">Consistent comparison (<tt>operator&lt;=&gt;</tt>)</td>
-      <td><a href="http://wg21.link/p0515r3">P0515R3</a></td>
+      <td><a href="https://wg21.link/p0515r3">P0515R3</a></td>
       <td class="partial" align="center">Partial</td>
     </tr>
       <tr> <!-- from Jacksonville -->
-        <td><a href="http://wg21.link/p0905r1">P0905R1</a></td>
+        <td><a href="https://wg21.link/p0905r1">P0905R1</a></td>
         <td class="svn" align="center">Clang 10</td>
       </tr>
       <tr> <!-- from Rapperswil -->
-        <td><a href="http://wg21.link/p1120r0">P1120R0</a></td>
+        <td><a href="https://wg21.link/p1120r0">P1120R0</a></td>
         <td rowspan="2" class="partial" align="center">Partial</td>
       </tr>
       <tr> <!-- from Kona 2019 -->
-        <td><a href="http://wg21.link/p1185r2">P1185R2</a></td>
+        <td><a href="https://wg21.link/p1185r2">P1185R2</a></td>
       </tr>
       <tr> <!-- from Cologne -->
-        <td><a href="http://wg21.link/p1186r3">P1186R3</a></td>
+        <td><a href="https://wg21.link/p1186r3">P1186R3</a></td>
         <td class="none" align="center">No</td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1630r1">P1630R1</a></td>
+        <td><a href="https://wg21.link/p1630r1">P1630R1</a></td>
         <td class="partial" align="center">Partial</td>
       </tr>
     <tr>
       <td>Access checking on specializations</td>
-      <td><a href="http://wg21.link/p0692r1">P0692R1</a></td>
+      <td><a href="https://wg21.link/p0692r1">P0692R1</a></td>
       <td class="partial" align="center">Partial</td>
     </tr>
     <tr>
       <td>Default constructible and assignable stateless lambdas</td>
-      <td><a href="http://wg21.link/p0624r2">P0624R2</a></td>
+      <td><a href="https://wg21.link/p0624r2">P0624R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td>Lambdas in unevaluated contexts</td>
-      <td><a href="http://wg21.link/p0315r4">P0315R4</a></td>
+      <td><a href="https://wg21.link/p0315r4">P0315R4</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <!-- Jacksonville papers -->
     <tr>
       <td><tt>[[no_unique_address]]</tt> attribute</td>
-      <td><a href="http://wg21.link/p0840r2">P0840R2</a></td>
+      <td><a href="https://wg21.link/p0840r2">P0840R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>
       <td><tt>[[likely]]</tt> and <tt>[[unlikely]]</tt> attributes</td>
-      <td><a href="http://wg21.link/p0479r5">P0479R5</a></td>
+      <td><a href="https://wg21.link/p0479r5">P0479R5</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td><tt>typename</tt> optional in more contexts</td>
-      <td><a href="http://wg21.link/p0634r3">P0634R3</a></td>
+      <td><a href="https://wg21.link/p0634r3">P0634R3</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Pack expansion in lambda <i>init-capture</i></td>
-      <td><a href="http://wg21.link/p0780r2">P0780R2</a></td>
+      <td><a href="https://wg21.link/p0780r2">P0780R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <!-- Rapperswil papers -->
     <tr>
       <td>Class types as non-type template parameters</td>
-      <td><a href="http://wg21.link/p0732r2">P0732R2</a></td>
+      <td><a href="https://wg21.link/p0732r2">P0732R2</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Destroying operator delete</td>
-      <td><a href="http://wg21.link/p0722r3">P0722R3</a></td>
+      <td><a href="https://wg21.link/p0722r3">P0722R3</a></td>
       <td class="full" align="center">Clang 6</td>
     </tr>
     <tr>
       <td rowspan="7">Relaxations of <tt>constexpr</tt> restrictions</td>
-      <td><a href="http://wg21.link/p1064r0">P1064R0</a></td>
+      <td><a href="https://wg21.link/p1064r0">P1064R0</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
       <tr> <!-- from San Diego -->
-        <td><a href="http://wg21.link/p1002r1">P1002R1</a></td>
+        <td><a href="https://wg21.link/p1002r1">P1002R1</a></td>
         <td class="full" align="center">Clang 8</td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1327r1">P1327R1</a></td>
+        <td><a href="https://wg21.link/p1327r1">P1327R1</a></td>
         <td rowspan="2" class="full" align="center">Clang 9</td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1330r0">P1330R0</a></td>
+        <td><a href="https://wg21.link/p1330r0">P1330R0</a></td>
       </tr>
       <tr> <!-- from Cologne -->
-        <td><a href="http://wg21.link/p1331r2">P1331R2</a></td>
+        <td><a href="https://wg21.link/p1331r2">P1331R2</a></td>
         <td rowspan="3" class="svn" align="center">SVN</td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1668r1">P1668R1</a></td>
+        <td><a href="https://wg21.link/p1668r1">P1668R1</a></td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p0784r7">P0784R7</a></td>
+        <td><a href="https://wg21.link/p0784r7">P0784R7</a></td>
       </tr>
     <tr>
       <td>Prohibit aggregates with user-declared constructors</td>
-      <td><a href="http://wg21.link/p1008r1">P1008R1</a></td>
+      <td><a href="https://wg21.link/p1008r1">P1008R1</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td>Feature test macros</td>
-      <td><a href="http://wg21.link/p0941r2">P0941R2</a></td>
+      <td><a href="https://wg21.link/p0941r2">P0941R2</a></td>
       <td class="full" align="center"><a href="#sd6">(see below)</a></td>
     </tr>
     <tr>
       <td><tt>explicit(bool)</tt></td>
-      <td><a href="http://wg21.link/p0892r2">P0892R2</a></td>
+      <td><a href="https://wg21.link/p0892r2">P0892R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <!-- San Diego papers -->
     <tr>
       <td>Signed integers are two's complement</td>
-      <td><a href="http://wg21.link/p1236r1">P1236R1</a></td>
+      <td><a href="https://wg21.link/p1236r1">P1236R1</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>
       <td><tt>char8_t</tt></td>
-      <td><a href="http://wg21.link/p0482r6">P0482R6</a></td>
+      <td><a href="https://wg21.link/p0482r6">P0482R6</a></td>
       <td class="full" align="center">Clang 7 <a href="#p0482">(11)</a></td>
     </tr>
     <tr>
       <td>Immediate functions (<tt>consteval</tt>)</td>
-      <td><a href="http://wg21.link/p1073r3">P1073R3</a></td>
+      <td><a href="https://wg21.link/p1073r3">P1073R3</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td><tt>std::is_constant_evaluated</tt></td>
-      <td><a href="http://wg21.link/p0595r2">P0595R2</a></td>
+      <td><a href="https://wg21.link/p0595r2">P0595R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>
       <td>Nested inline namespaces</td>
-      <td><a href="http://wg21.link/p1094r2">P1094R2</a></td>
+      <td><a href="https://wg21.link/p1094r2">P1094R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <!-- Kona 2019 papers -->
     <tr>
       <td rowspan="2">Structured binding extensions</td>
-      <td><a href="http://wg21.link/p1091r3">P1091R3</a></td>
+      <td><a href="https://wg21.link/p1091r3">P1091R3</a></td>
       <td rowspan="2" class="partial" align="center">Partial</td>
     </tr>
       <tr>
-        <td><a href="http://wg21.link/p1381r1">P1381R1</a></td>
+        <td><a href="https://wg21.link/p1381r1">P1381R1</a></td>
       </tr>
     <tr>
       <td rowspan="2">Stronger Unicode requirements</td>
-      <td><a href="http://wg21.link/p1041r4">P1041R4</a></td>
+      <td><a href="https://wg21.link/p1041r4">P1041R4</a></td>
       <td rowspan="2" class="full" align="center">Yes</td>
     </tr>
       <tr>
-        <td><a href="http://wg21.link/p1139r2">P1139R2</a></td>
+        <td><a href="https://wg21.link/p1139r2">P1139R2</a></td>
       </tr>
     <tr>
       <td>Parenthesized initialization of aggregates</td>
-      <td><a href="http://wg21.link/p0960r3">P0960R3</a></td>
+      <td><a href="https://wg21.link/p0960r3">P0960R3</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td rowspan="4">Modules</td>
-      <td><a href="http://wg21.link/p1103r3">P1103R3</a></td>
+      <td><a href="https://wg21.link/p1103r3">P1103R3</a></td>
       <td class="partial" align="center">Partial</td>
     </tr>
       <tr> <!-- from Cologne -->
-        <td><a href="http://wg21.link/p1766r1">P1766R1</a> (<a href="#dr">DR</a>)</td>
+        <td><a href="https://wg21.link/p1766r1">P1766R1</a> (<a href="#dr">DR</a>)</td>
         <td rowspan="3" class="none" align="center">No</td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1811r0">P1811R0</a></td>
+        <td><a href="https://wg21.link/p1811r0">P1811R0</a></td>
       </tr>
       <tr>
-        <td><a href="http://wg21.link/p1703r1">P1703R1</a></td>
+        <td><a href="https://wg21.link/p1703r1">P1703R1</a></td>
       </tr>
     <tr>
       <td>Coroutines</td>
-      <td><a href="http://wg21.link/p0912r5">P0912R5</a></td>
+      <td><a href="https://wg21.link/p0912r5">P0912R5</a></td>
       <td class="partial" align="center">Partial</td>
     </tr>
     <!-- Cologne 2019 papers -->
     <tr>
       <td>Deprecate <tt>a[b,c]</tt></td>
-      <td><a href="http://wg21.link/p1161r3">P1161R3</a></td>
+      <td><a href="https://wg21.link/p1161r3">P1161R3</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>
       <td>Deprecate some problematic uses of <tt>volatile</tt></td>
-      <td><a href="http://wg21.link/p1152r4">P1152R4</a></td>
+      <td><a href="https://wg21.link/p1152r4">P1152R4</a></td>
       <td class="svn" align="center">SVN</td>
     </tr>
     <tr>
       <td><tt>[[nodiscard("with reason")]]</tt></td>
-      <td><a href="http://wg21.link/p1301r4">P1301R4</a></td>
+      <td><a href="https://wg21.link/p1301r4">P1301R4</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>
       <td><tt>using enum</tt></td>
-      <td><a href="http://wg21.link/p1099r5">P1099R5</a></td>
+      <td><a href="https://wg21.link/p1099r5">P1099R5</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Class template argument deduction for aggregates</td>
-      <td><a href="http://wg21.link/p1816r0">P1816R0</a></td>
+      <td><a href="https://wg21.link/p1816r0">P1816R0</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Class template argument deduction for alias templates</td>
-      <td><a href="http://wg21.link/p1814r0">P1814R0</a></td>
+      <td><a href="https://wg21.link/p1814r0">P1814R0</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Permit conversions to arrays of unknown bound</td>
-      <td><a href="http://wg21.link/p0388r4">P0388R4</a></td>
+      <td><a href="https://wg21.link/p0388r4">P0388R4</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td><tt>constinit</tt></td>
-      <td><a href="http://wg21.link/p1143r2">P1143R2</a></td>
+      <td><a href="https://wg21.link/p1143r2">P1143R2</a></td>
       <td class="svn" align="center">SVN</td>
     </tr>
 </table>
 
 <p>
 <span id="p0482">(11): Prior to Clang 8, this feature is not enabled by
 <tt>-std=c++2a</tt>, but can be enabled with <tt>-fchar8_t</tt>.
 </span>

  <tr>
     <th>Document</th>
     <th>Latest draft</th>
     <th>Compiler flag</th>
     <th>Available in Clang?</th>
  </tr>
     <tr id="sd6">
       <td rowspan="6">SD-6: SG10 feature test recommendations</td>
-      <td rowspan="6"><a href="http://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations">SD-6</a></td>
+      <td rowspan="6"><a href="https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations">SD-6</a></td>
       <td rowspan="6">N/A</td>
       <td class="full" align="center">
-        Clang 3.4 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3745">N3745</a>)</br>
+        Clang 3.4 (<a href="https://wg21.link/n3745">N3745</a>)</br>
       </td>
     </tr>
     <tr>
       <td class="full" align="center">
-        Clang 3.6 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4200">N4200</a>)</a>
+        Clang 3.6 (<a href="https://wg21.link/n4200">N4200</a>)</a>
       </td>
     </tr>
     <tr>
       <td class="full" align="center">
-        Clang 4 (<a href="http://wg21.link/p0096r3">P0096R3</a>)</a>
+        Clang 4 (<a href="https://wg21.link/p0096r3">P0096R3</a>)</a>
       </td>
     </tr>
     <tr>
       <td class="full" align="center">
-        Clang 5 (<a href="http://wg21.link/p0096r4">P0096R4</a>)</a>
+        Clang 5 (<a href="https://wg21.link/p0096r4">P0096R4</a>)</a>
       </td>
     </tr>
     <tr>
       <td class="full" align="center">
-        Clang 7 (<a href="http://wg21.link/p0096r5">P0096R5</a>)</a>
+        Clang 7 (<a href="https://wg21.link/p0096r5">P0096R5</a>)</a>
       </td>
     </tr>
     <tr>
       <td class="partial" align="center">
-        WIP (<a href="http://wg21.link/p1353r0">P1353R0</a>)
+        WIP (<a href="https://wg21.link/p1353r0">P1353R0</a>)
       </td>
     </tr>
     <!-- FIXME: Implement latest recommendations.
     <tr>
       <td class="svn" align="center">
-        SVN (<a href="http://wg21.link/p0096r3">P0096R3</a>)</a>
+        SVN (<a href="https://wg21.link/p0096r3">P0096R3</a>)</a>
       </td>
     </tr>
     -->
     <!-- No compiler support is known to be needed for:
            * Concurrency TS
            * Parallelism TS (v1, v2)
            * Ranges TS
            * Networking TS
            * File System TS
     -->
     <tr>
       <td>[TS] Concepts</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0121r0.pdf">P0121R0</a></td>
+      <td><a href="https://wg21.link/p0121r0">P0121R0</a></td>
       <td></td>
       <td class="na" align="center">Superseded by <a href="#p0734">P0734R0</a></td>
     </tr>
     <tr>
       <!-- track unimplemented Coroutines features: p0913r1 p0914r1 p1356r0 -->
       <td rowspan="2">[TS] Coroutines</td>
       <td rowspan="2"><a href="https://isocpp.org/files/papers/N4663.pdf">N4663</a></td>
       <td><tt>-fcoroutines-ts<br>-stdlib=libc++</tt></td>
       <td class="full" align="center">Clang 5</td>
     </tr>
     <tr>
       <td><tt>-std=c++2a<br>-stdlib=libc++</tt></td>
       <td class="na" align="center">Superseded by <a href="#p0912">P0912R5</a></td>
     </tr>
     <tr>
       <td>[TS] Library Fundamentals, Version 1 (invocation type traits)</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html">N4480</a></td>
+      <td><a href="https://wg21.link/n4480">N4480</a></td>
       <td>N/A</td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>[TS] Library Fundamentals, Version 2 (<tt>source_location</tt>)</td>
-     <td><a href="http://wg21.link/n4617">N4617</a></td>
+     <td><a href="https://wg21.link/n4617">N4617</a></td>
       <td>N/A</td>
       <td class="full" align="center">Clang 9 (<a href="docs/LanguageExtensions.html#source-location-builtins">documentation</a>)</td>
     </tr>
     <tr>
       <td>[TS] Modules</td>
-      <td><a href="http://wg21.link/n4720">N4720</a></td>
+      <td><a href="https://wg21.link/n4720">N4720</a></td>
       <td><tt>-fmodules-ts</tt></td>
       <td class="na" align="center">Superseded by <a href="#p1103">P1103R3</a></td>
     </tr>
     <tr>
       <td>[DRAFT TS] Reflection</td>
-      <td><a href="http://wg21.link/n4746">N4746</a></td>
+      <td><a href="https://wg21.link/n4746">N4746</a></td>
       <td></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>[TS] Transactional Memory</td>
-      <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4514.pdf">N4514</a></td>
+      <td><a href="https://wg21.link/n4514">N4514</a></td>
       <td></td>
       <td class="none" align="center">No</td>
     </tr>
 </table>
 </details>
 
 </div>
 </body>
 </html>

clang/www/demo/DemoInfo.html

 
 <html>
 <head>
 <title>
 Demo page information
 </title>
 </head>
 
 <body>
 
 <h1>Demo page information</h1>
 
-<p>Press "back" or <a href=".">click here</a> to return to the demo 
+<p>Press "back" or <a href=".">click here</a> to return to the demo
 page.</p>
 
 <h2><a name="hints">Hints and Advice</a></h2>
 
 <ul>
 <li>The generated LLVM code will be easier to read if
 you use stdio (e.g., printf) than iostreams (e.g., std::cout).</li>
 
-<li>Unused inline functions and methods are not generated.  Instead 
+<li>Unused inline functions and methods are not generated.  Instead
 of '<tt>class foo { void bar() {}};</tt>',
 try writing '<tt>class foo { void bar(); }; void foo::bar() {}</tt>'.</li>
 
 <li>If you want to try out a file that uses non-standard header files,  you should
   preprocess it (e.g., with the <tt>-save-temps</tt> or <tt>-E</tt> options to
   <tt>gcc</tt>) then upload the result.</li>
 
 </ul>
 
 
 <h2><a name="demangle">Demangle C++ names with C++ filt</a></h2>
 
 <p>
-Select this option if you want to run the output LLVM IR through "c++filt", 
-which converts 'mangled' C++ names to their unmangled version. 
-Note that LLVM code produced will not be lexically valid, but it will 
+Select this option if you want to run the output LLVM IR through "c++filt",
+which converts 'mangled' C++ names to their unmangled version.
+Note that LLVM code produced will not be lexically valid, but it will
 be easier to understand.
 </p>
 
 <h2><a name="lto">Run link-time optimizer</a></h2>
 
 <p>
 Select this option to run the LLVM link-time optimizer, which is designed to
 optimize across files in your application.  Since the demo page doesn't allow
 you to upload multiple files at once, and does not link in any libraries, we
-configured the demo page optimizer to assume there are no calls 
-coming in from outside the source file, allowing it to optimize more 
+configured the demo page optimizer to assume there are no calls
+coming in from outside the source file, allowing it to optimize more
 aggressively.</p>
 
-<p>Note that you have to define 'main' in your program for this 
+<p>Note that you have to define 'main' in your program for this
 to make much of a difference.
 </p>
 
 <h2><a name="stats">Show detailed pass statistics</a></h2>
 
 <p>
 Select this option to enable compilation timings and statistics from various
 optimizers.</p>
 
 
 <h2><a name="bcanalyzer">Analyze generated bytecode</a></h2>
 
 <p>
-Select this option to run the <a 
-href="http://llvm.org/cmds/llvm-bcanalyzer.html">llvm-bcanalyzer</a> tool
+Select this option to run the <a
+href="https://llvm.org/docs/CommandGuide/llvm-bcanalyzer.html">llvm-bcanalyzer</a> tool
 on the generated bytecode, which introspects into the format of the .bc file
 itself.  </p>
 
 
 <h2><a name="llvm2cpp">Show C++ API code</a></h2>
 
 <p>
-Select this option to run the <a 
-href="http://llvm.org/cmds/llvm2cpp.html">llvm2cpp</a> tool
+Select this option to run the <a
+href="https://llvm.org/cmds/llvm2cpp.html">llvm2cpp</a> tool
 on the generated bytecode, which auto generates the C++ API calls that could
 be used to create the .bc file.
 </p>
 
 </body>
 </html>
-

clang/www/features.html

 
 <p>Here you can see that you don't even need to see the original source code to
 understand what is wrong based on the Clang error: Because Clang prints a
 caret, you know exactly <em>which</em> plus it is complaining about.  The range
 information highlights the left and right side of the plus which makes it
 immediately obvious what the compiler is talking about, which is very useful for
 cases involving precedence issues and many other situations.</p>
 
-<p>Clang diagnostics are very polished and have many features.  For more 
+<p>Clang diagnostics are very polished and have many features.  For more
 information and examples, please see the <a href="diagnostics.html">Expressive
 Diagnostics</a> page.</p>
 
 <!--=======================================================================-->
 <h3><a name="gcccompat">GCC Compatibility</a></h3>
 <!--=======================================================================-->
 
 <p>GCC is currently the defacto-standard open source compiler today, and it
 routinely compiles a huge volume of code.  GCC supports a huge number of
-extensions and features (many of which are undocumented) and a lot of 
+extensions and features (many of which are undocumented) and a lot of
 code and header files depend on these features in order to build.</p>
 
 <p>While it would be nice to be able to ignore these extensions and focus on
 implementing the language standards to the letter, pragmatics force us to
 support the GCC extensions that see the most use.  Many users just want their
 code to compile, they don't care to argue about whether it is pedantically C99
 or not.</p>
 

 that are safe.  Making this efficient and getting this right requires a
 significant amount of engineering and algorithmic work that simply are
 unnecessary for a simple static compiler.</p>
 
 <p>The beauty of the clang approach is that it does not restrict how you use it.
 In particular, it is possible to use the clang preprocessor and parser to build
 an extremely quick and light-weight on-the-fly code generator (similar to TCC)
 that does not build an AST at all.   As an intermediate step, clang supports
-using the current AST generation and semantic analysis code and having a code 
+using the current AST generation and semantic analysis code and having a code
 generation client free the AST for each function after code generation. Finally,
 clang provides support for building and retaining fully-fledged ASTs, and even
 supports writing them out to disk.</p>
 
 <p>Designing the libraries with clean and simple APIs allows these high-level
 policy decisions to be determined in the client, instead of forcing "one true
 way" in the implementation of any of these libraries.  Getting this right is
 hard, and we don't always get it right the first time, but we fix any problems

 to allow this.  We feel that the license encourages contributors to pick up the
 source and work with it, and believe that those individuals and organizations
 will contribute back their work if they do not want to have to maintain a fork
 forever (which is time consuming and expensive when merges are involved).
 Further, nobody makes money on compilers these days, but many people need them
 to get bigger goals accomplished: it makes sense for everyone to work
 together.</p>
 
-<p>For more information about the LLVM/clang license, please see the <a 
-href="http://llvm.org/docs/DeveloperPolicy.html#license">LLVM License 
+<p>For more information about the LLVM/clang license, please see the <a
+href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">LLVM License
 Description</a> for more information.</p>
 
 
 
 <!--*************************************************************************-->
 <h2><a name="design">Internal Design and Implementation</a></h2>
 <!--*************************************************************************-->
 
 <!--=======================================================================-->
 <h3><a name="real">A real-world, production quality compiler</a></h3>
 <!--=======================================================================-->
 
 <p>
 Clang is designed and built by experienced compiler developers who
-are increasingly frustrated with the problems that <a 
+are increasingly frustrated with the problems that <a
 href="comparison.html">existing open source compilers</a> have.  Clang is
 carefully and thoughtfully designed and built to provide the foundation of a
 whole new generation of C/C++/Objective C development tools, and we intend for
 it to be production quality.</p>
 
 <p>Being a production quality compiler means many things: it means being high
 performance, being solid and (relatively) bug free, and it means eventually
 being used and depended on by a broad range of people.  While we are still in

clang/www/get_involved.html

 
 <h2>Contribute</h2>
 
 See the <a href="hacking.html">hacking</a> document for information on how
 to author patches.
 
 <h2>Follow what's going on</h2>
 
-<p>Clang is a subproject of the <a href="http://llvm.org">LLVM Project</a>, but
+<p>Clang is a subproject of the <a href="https://llvm.org">LLVM Project</a>, but
 has its own mailing lists because the communities have people with different
 interests.  The two clang lists are:</p>
 
 <ul>
-<li><a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits
+<li><a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits
 </a> - This list is for patch submission/discussion.</li>
 
-<li><a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a> - 
+<li><a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a> -
 This list is for everything else Clang related (questions and answers, design
 discussions, etc).</li>
 
 </ul>
 
 <p>If you are interested in clang only, these two lists should be all
 you need.  If you are interested in the LLVM optimizer and code generator,
-please consider signing up for <a 
-href="http://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a> and <a
-href="http://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
+please consider signing up for <a
+href="https://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a> and <a
+href="https://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
 as well.</p>
 
 
 <p>The most common way to talk with other developers on the project is through
-the <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev mailing
+the <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev mailing
 list</a>.  The clang mailing list is a very friendly place and we welcome
 newcomers.  In addition to the cfe-dev list, a significant amount of design
-discussion takes place on the <a 
-href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits mailing
+discussion takes place on the <a
+href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits mailing
 list</a>.  All of these lists have archives, so you can browse through previous
 discussions or follow the list development on the web if you prefer.</p>
 
 <p>You can also follow the <a href="http://planet.clang.org/">Planet Clang</a>
 community news feed which offers a window into the world, work and lives of
 Clang developers, contributors and the standards they implement.</p>
 
 <p>If you're looking for something to work on, check out our <a

clang/www/get_started.html

 
 <ol>
   <li>Get the required tools.
   <ul>
     <li>See
       <a href="https://llvm.org/docs/GettingStarted.html#requirements">
       Getting Started with the LLVM System - Requirements</a>.</li>
     <li>Note also that Python is needed for running the test suite.
-      Get it at: <a href="http://www.python.org/download">
-      http://www.python.org/download</a></li>
+      Get it at: <a href="https://www.python.org/downloads/">
+      https://www.python.org/downloads/</a></li>
     <li>Standard build process uses CMake. Get it at:
-      <a href="http://www.cmake.org/download">
-      http://www.cmake.org/download</a></li>
+      <a href="https://cmake.org/download/">
+      https://cmake.org/download/</a></li>
   </ul>
 
   <li>Check out the LLVM project:
   <ul>
     <li>Change directory to where you want the llvm directory placed.</li>
     <li><tt>git clone https://github.com/llvm/llvm-project.git</tt></li>
   </ul>
   </li>

clang/www/hacking.html

<ul>
       <li><a href="#irgen">LLVM IR Generation</a></li>
     </ul>
 
   <!--=====================================================================-->
   <h2 id="style">Coding Standards</h2>
   <!--=====================================================================-->
 
   <p>Clang follows the
-  LLVM <a href="http://llvm.org/docs/CodingStandards.html">Coding
+  LLVM <a href="https://llvm.org/docs/CodingStandards.html">Coding
   Standards</a>. When submitting patches, please take care to follow these standards
   and to match the style of the code to that present in Clang (for example, in
   terms of indentation, bracing, and statement spacing).</p>
 
   <p>Clang has a few additional coding standards:</p>
   <ul>
     <li><i>cstdio is forbidden</i>: library code should not output diagnostics
       or other information using <tt>cstdio</tt>; debugging routines should
       use <tt>llvm::errs()</tt>. Other uses of <tt>cstdio</tt> impose behavior
       upon clients and block integrating Clang as a library. Libraries should
       support <tt>raw_ostream</tt> based interfaces for textual
-      output. See <a href="http://llvm.org/docs/CodingStandards.html#ll_raw_ostream">Coding
+      output. See <a href="https://llvm.org/docs/CodingStandards.html#use-raw-ostream">Coding
       Standards</a>.</li>
   </ul>
 
   <!--=====================================================================-->
   <h2 id="docs">Developer Documentation</h2>
   <!--=====================================================================-->
 
   <p>Both Clang and LLVM use doxygen to provide API documentation. Their
   respective web pages (generated nightly) are here:</p>
     <ul>
-      <li><a href="http://clang.llvm.org/doxygen">Clang</a></li>
-      <li><a href="http://llvm.org/doxygen">LLVM</a></li>
+      <li><a href="https://clang.llvm.org/doxygen">Clang</a></li>
+      <li><a href="https://llvm.org/doxygen">LLVM</a></li>
     </ul>
 
   <p>For work on the LLVM IR generation, the LLVM assembly language
-  <a href="http://llvm.org/docs/LangRef.html">reference manual</a> is
+  <a href="https://llvm.org/docs/LangRef.html">reference manual</a> is
   also useful.</p>
 
   <!--=====================================================================-->
   <h2 id="debugging">Debugging</h2>
   <!--=====================================================================-->
 
   <p>Inspecting data structures in a debugger:</p>
     <ul>
       <li>Many LLVM and Clang data structures provide
         a <tt>dump()</tt> method which will print a description of the
         data structure to <tt>stderr</tt>.</li>
       <li>The <a href="docs/InternalsManual.html#QualType"><tt>QualType</tt></a>
       structure is used pervasively. This is a simple value class for
       wrapping types with qualifiers; you can use
       the <tt>isConstQualified()</tt>, for example, to get one of the
       qualifiers, and the <tt>getTypePtr()</tt> method to get the
       wrapped <tt>Type*</tt> which you can then dump.</li>
-      <li>For <a href="http://lldb.llvm.org"> <tt>LLDB</tt></a> users there are
+      <li>For <a href="https://lldb.llvm.org"> <tt>LLDB</tt></a> users there are
       data formatters for clang data structures in
       <a href="https://github.com/llvm/llvm-project/blob/master/clang/utils/ClangDataFormat.py">
       <tt>clang/utils/ClangDataFormat.py</tt></a>.</li>
     </ul>
 
   <!--=====================================================================-->
   <h3 id="debuggingVisualStudio">Debugging using Visual Studio</h3>
   <!--=====================================================================-->
</pre>
   <p>If you used the <tt>make VERBOSE=1</tt> option, the terminal
   output will reflect the error messages from the compiler and
   test runner.</p>
 
   <p>The regression suite can also be run with Valgrind by running
   <tt>make test VG=1</tt> in the top-level clang directory.</p>
 
   <p>For more intensive changes, running
-  the <a href="http://llvm.org/docs/TestingGuide.html#testsuiterun">LLVM
+  the <a href="https://llvm.org/docs/TestingGuide.html#quick-start">LLVM
   Test Suite</a> with clang is recommended. Currently the best way to
   override LLVMGCC, as in: <tt>make LLVMGCC="clang -std=gnu89"
   TEST=nightly report</tt> (make sure <tt>clang</tt> is in your PATH or use the
   full path).</p>
 
   <!--=====================================================================-->
   <h3 id="testingWindows">Testing using Visual Studio on Windows</h3>
   <!--=====================================================================-->
 
   <p>The Clang test suite can be run from either Visual Studio or
   the command line.</p>
 
   <p>Note that the test runner is based on
   Python, which must be installed.  Find Python at:
-  <a href="http://www.python.org/download/">http://www.python.org/download/</a>.
+  <a href="https://www.python.org/downloads/">https://www.python.org/downloads/</a>.
   Download the latest stable version.</p>
 
   <p>The GnuWin32 tools are also necessary for running the tests.
   Get them from <a href="http://getgnuwin32.sourceforge.net/">
   http://getgnuwin32.sourceforge.net/</a>.
   If the environment variable <tt>%PATH%</tt> does not have GnuWin32,
   or if other grep(s) supercedes GnuWin32 on <tt>%PATH%,</tt>
   you should specify <tt>LLVM_LIT_TOOLS_DIR</tt>
   to CMake explicitly.</p>
 
   <p>The cmake build tool is set up to create Visual Studio project files
   for running the tests, "clang-test" being the root.  Therefore, to
   run the test from Visual Studio, right-click the clang-test project
   and select "Build".</p>
 
   <p>
     Please see also
-    <a href="http://llvm.org/docs/GettingStartedVS.html">Getting Started
+    <a href="https://llvm.org/docs/GettingStartedVS.html">Getting Started
     with the LLVM System using Microsoft Visual Studio</a> and
-    <a href="http://llvm.org/docs/CMake.html">Building LLVM with CMake</a>.
+    <a href="https://llvm.org/docs/CMake.html">Building LLVM with CMake</a>.
   </p>
 
   <!--=====================================================================-->
   <h3 id="testingCommands">Testing on the Command Line</h3>
   <!--=====================================================================-->
 
   <p>If you want more control over how the tests are run, it may
   be convenient to run the test harness on the command-line directly. Before
</pre>
 
   <!--=====================================================================-->
   <h2 id="patches">Creating Patch Files</h2>
   <!--=====================================================================-->
 
   <p>To return changes to the Clang team, unless you have checkin
   privileges, the preferred way is to send patch files
   <a href="https://llvm.org/docs/Contributing.html#how-to-submit-a-patch">using LLVM's Phabricator</a> with an explanation of what the patch is for. Clang follows <a
-  href="http://llvm.org/docs/DeveloperPolicy.html">LLVM's developer policy</a>.
+  href="https://llvm.org/docs/DeveloperPolicy.html">LLVM's developer policy</a>.
   If your patch requires a wider discussion (for example, because it is an
   architectural change), you can use the cfe-dev mailing list.</p>
 
   <p>To create these patch files, change directory
   to the llvm/tools/clang root and run:</p>
 
   <pre>svn diff (relative path) >(patch file name)</pre>
 
<p>The LLVM IR generation part of clang handles conversion of the
     "codegen", and the Clang code for this lives
     in <tt>lib/CodeGen</tt>.</p>
 
   <p>The output is most easily inspected using the <tt>-emit-llvm</tt>
     option to clang (possibly in conjunction with <tt>-o -</tt>). You
     can also use <tt>-emit-llvm-bc</tt> to write an LLVM bitcode file
     which can be processed by the suite of LLVM tools
     like <tt>llvm-dis</tt>, <tt>llvm-nm</tt>, etc. See the LLVM
-    <a href="http://llvm.org/docs/CommandGuide/">Command Guide</a>
+    <a href="https://llvm.org/docs/CommandGuide/">Command Guide</a>
     for more information.</p>
 
 </div>
 </body>
 </html>

clang/www/index.html

 <!--#include virtual="menu.html.incl"-->
 <div id="content">
   <!--*********************************************************************-->
   <h1>Clang: a C language family frontend for LLVM</h1>
   <!--*********************************************************************-->
 
   <p>The Clang project provides a language front-end and tooling infrastructure
   for languages in the C language family (C, C++, Objective C/C++, OpenCL,
-  CUDA, and RenderScript) for the <a href="http://www.llvm.org/">LLVM</a>
+  CUDA, and RenderScript) for the <a href="https://www.llvm.org/">LLVM</a>
   project. Both a GCC-compatible compiler driver (<tt>clang</tt>) and an
   MSVC-compatible compiler driver (<tt>clang-cl.exe</tt>) are provided. You
   can <a href="get_started.html">get and build</a> the source today.</p>
 
   <!--=====================================================================-->
   <h2 id="goals">Features and Goals</h2>
   <!--=====================================================================-->
 

clang/www/related.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>Clang Related Projects</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
<div id="content">
     <p>Please email <a href="get_involved.html">cfe-dev</a> if you have a Clang related project you would like
       added to this list.</p>
 
     <dl>
       <dt>FreeBSD Clang Page</dt>
       <dd>
         <p>
           <b>Site:</b>
-          <a href="http://wiki.freebsd.org/BuildingFreeBSDWithClang">
-            http://wiki.freebsd.org/BuildingFreeBSDWithClang</a>
+          <a href="https://wiki.freebsd.org/BuildingFreeBSDWithClang">
+            https://wiki.freebsd.org/BuildingFreeBSDWithClang</a>
         </p>
         <p>
           This is an effort to get FreeBSD to build with clang/llvm.
         </p>
       </dd>
 
       <dt>Chromium Clang Page</dt>
       <dd>
         <p>
           <b>Site:</b>
           <a href="https://chromium.googlesource.com/chromium/src/+/master/docs/clang.md">
             https://chromium.googlesource.com/chromium/src/+/master/docs/clang.md</a>
         </p>
         <p>
           Notes on using Clang to build the Chromium web browser.
         </p>
       </dd>
 
       <dt>Debian Clang Page</dt>
       <dd>
         <p>
           <b>Sites:</b><br />
-        <a href="http://clang.debian.net/">http://clang.debian.net/</a><br />
-        <a href="http://wiki.debian.org/llvm-clang">
-            http://wiki.debian.org/llvm-clang</a>
+        <a href="https://clang.debian.net/">https://clang.debian.net/</a><br />
+        <a href="https://wiki.debian.org/llvm-clang">
+            https://wiki.debian.org/llvm-clang</a>
         </p>
         <p>
           Notes on using Clang to rebuild the whole Debian archive.
         </p>
       </dd>
 
       <dt>Include what you use</dt>
       <dd>
<dl>
         DXR is a code search and navigation tool aimed at making sense of large projects like Firefox. It supports full-text and regex searches as well as structural queries like "Find all the callers of this function."
         </p>
       </dd>
 
       <dt>CodeCompass</dt>
       <dd>
         <p>
           <b>Site:</b>
-        <a href="http://github.com/Ericsson/CodeCompass">http://github.com/Ericsson/CodeCompass</a>
+        <a href="https://github.com/Ericsson/CodeCompass">https://github.com/Ericsson/CodeCompass</a>
         </p>
         <p>
         CodeCompass is an open-source, extensible code comprehension framework which uses LLVM/Clang to analyze and visualize C and C++ projects. It also supports both regex-based text search, discovering complex C/C++ language elements, with advanced navigation and visualisation.
         </p>
       </dd>
 
       <dt>CodeChecker</dt>
       <dd>
         <p>
           <b>Site:</b>
-        <a href="http://github.com/Ericsson/CodeChecker">http://github.com/Ericsson/CodeChecker</a>
+        <a href="https://github.com/Ericsson/CodeChecker">https://github.com/Ericsson/CodeChecker</a>
         </p>
         <p>
         CodeChecker is a static analysis infrastructure built on the LLVM/Clang Static Analyzer toolchain. It provides a user interface to execute analysis of C/C++ projects with Clang SA and Clang-Tidy, which outputs are then stored into a database navigable via a web application. This web application and a corresponding command-line tool supports a variety of report management and issue triaging options, such as difference view between analyses, automatic incremental analysis, marking and commenting on individual reports.
         </p>
       </dd>
 
     </dl>
   </div>
 </body>
 </html>

compiler-rt/www/index.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>"compiler-rt" Runtime Library</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 
 <body>
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
   <!--*********************************************************************-->
   <h1>"compiler-rt" runtime libraries</h1>
   <!--*********************************************************************-->
-  
   <p>The compiler-rt project consists of:
   <ul>
   <li>
     <p><b>builtins</b> - a simple library that provides an implementation
     of the low-level target-specific hooks required by code generation and
     other runtime components.  For example, when compiling for a 32-bit target,
     converting a double to a 64-bit unsigned integer is compiling into a runtime
     call to the "__fixunsdfdi" function.  The builtins library provides
     optimized implementations of this and other low-level routines, either in
     target-independent C form, or as a heavily-optimized assembly.</p>
     <p>builtins provides full support for the libgcc interfaces on supported
     targets and high performance hand tuned implementations of commonly used
     functions like __floatundidf in assembly that are dramatically faster than
     the libgcc implementations. It should be very easy to bring builtins to
     support a new target by adding the new routines needed by that target.</p>
   </li>
   <li>
     <b>sanitizer runtimes</b> - runtime libraries that are required to run
     the code with sanitizer instrumentation. This includes runtimes for:
     <ul>
-    <li><a href="http://clang.llvm.org/docs/AddressSanitizer.html">AddressSanitizer</a></li>
-    <li><a href="http://clang.llvm.org/docs/ThreadSanitizer.html">ThreadSanitizer</a></li>
-    <li><a href="http://clang.llvm.org/docs/UsersManual.html#opt-fsanitize-undefined">UndefinedBehaviorSanitizer</a></li>
-    <li><a href="http://clang.llvm.org/docs/MemorySanitizer.html">MemorySanitizer</a></li>
-    <li><a href="http://clang.llvm.org/docs/LeakSanitizer.html">LeakSanitizer</a></li>
-    <li><a href="http://clang.llvm.org/docs/DataFlowSanitizer.html">DataFlowSanitizer</a></li>
+    <li><a href="https://clang.llvm.org/docs/AddressSanitizer.html">AddressSanitizer</a></li>
+    <li><a href="https://clang.llvm.org/docs/ThreadSanitizer.html">ThreadSanitizer</a></li>
+    <li><a href="https://clang.llvm.org/docs/UsersManual.html#opt-fsanitize-undefined">UndefinedBehaviorSanitizer</a></li>
+    <li><a href="https://clang.llvm.org/docs/MemorySanitizer.html">MemorySanitizer</a></li>
+    <li><a href="https://clang.llvm.org/docs/LeakSanitizer.html">LeakSanitizer</a></li>
+    <li><a href="https://clang.llvm.org/docs/DataFlowSanitizer.html">DataFlowSanitizer</a></li>
     </ul>
   </li>
   <li>
     <b>profile</b> - library which is used to collect coverage information.
   </li>
   <li>
     <b>BlocksRuntime</b> - a target-independent implementation of Apple "Blocks"
     runtime interfaces.
   </li>
   </ul>
   </p>
 
-  <p>All of the code in the compiler-rt project is <a 
-     href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+  <p>All of the code in the compiler-rt project is <a
+     href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">dual licensed</a>
      under the MIT license and the UIUC License (a BSD-like license).</p>
 
   <!--=====================================================================-->
   <h2 id="users">Clients</h2>
   <!--=====================================================================-->
 
   <p>Currently compiler-rt is primarily used by
-    the <a href="http://clang.llvm.org">Clang</a>
-    and <a href="http://llvm.org">LLVM</a> projects as the implementation for
+    the <a href="https://clang.llvm.org">Clang</a>
+    and <a href="https://llvm.org">LLVM</a> projects as the implementation for
     the runtime compiler support libraries. For more information on using
     compiler-rt with Clang, please see the Clang
-    <a href="http://clang.llvm.org/get_started.html">Getting Started</a>
+    <a href="https://clang.llvm.org/get_started.html">Getting Started</a>
     page.</p>
-  
   <!--=====================================================================-->
   <h2 id="requirements">Platform Support</h2>
   <!--=====================================================================-->
 
    <p><b>builtins</b> is known to work on the following platforms:</p>
    <ul>
    <li>Machine Architectures: i386, X86-64, SPARC64, ARM, PowerPC, PowerPC 64.</li>
    <li>OS: AuroraUX, DragonFlyBSD, FreeBSD, NetBSD, Linux, Darwin.</li>
    </ul>
 
    <p>Most sanitizer runtimes are supported only on Linux x86-64. See tool-specific
-   pages in <a href="http://clang.llvm.org/docs/index.html">Clang docs</a> for more
+   pages in <a href="https://clang.llvm.org/docs/index.html">Clang docs</a> for more
    details.</p>
 
   <!--=====================================================================-->
   <h2 id="dir-structure">Source Structure</h2>
   <!--=====================================================================-->
 
    <p>A short explanation of the directory structure of compiler-rt:</p>
 
    <p>For testing it is possible to build a generic library and an optimized library.
        The optimized library is formed by overlaying the optimized versions onto the generic library.
        Of course, some architectures have additional functions,
        so the optimized library may have functions not found in the generic version.</p>
 
    <ul>
     <li> include/ contains headers that can be included in user programs (for example,
          users may directly call certain function from sanitizer runtimes).</li>
     <li> lib/ contains libraries implementations. </li>
     <li> lib/builtins is a generic portable implementation of <b>builtins</b> routines.</li>
     <li> lib/builtins/(arch) has optimized versions of some routines
          for the supported architectures.</li>
     <li> test/ contains test suites for compiler-rt runtimes.</li>
    </ul>
-    
   <!--=====================================================================-->
   <h2>Get it and get involved!</h2>
   <!--=====================================================================-->
-  
   <p>Generally, you need to build LLVM/Clang in order to build compiler-rt. You
     can build it either together with llvm and clang, or separately.
 
   <p>To build it together, simply add compiler-rt to the -DLLVM_ENABLE_PROJECTS= option to
     cmake.
 
   <p>To build it separately, first
-  <a href="http://llvm.org/docs/CMake.html#quick-start">build LLVM</a>
+  <a href="https://llvm.org/docs/CMake.html#quick-start">build LLVM</a>
   separately to get llvm-config binary, and then run:
 
   <ul>
   <li>cd llvm-project</li>
   <li>mkdir build-compiler-rt</li>
   <li>cd build-compiler-rt</li>
   <li>cmake ../compiler-rt -DLLVM_CONFIG_PATH=/path/to/llvm-config</li>
   <li>make</li>
   </ul>
 
   <p>Tests for sanitizer runtimes are ported to
-  <a href="http://llvm.org/docs/CommandGuide/lit.html">llvm-lit</a> and are
+  <a href="https://llvm.org/docs/CommandGuide/lit.html">llvm-lit</a> and are
   run by <b>make check-all</b> command in LLVM/Clang/compiler-rt build tree.</p>
 
   <p>compiler-rt libraries are installed to the system with <b>make install</b>
   command in either LLVM/Clang/compiler-rt or standalone
   compiler-rt build tree.</p>
 
   <p>compiler-rt doesn't have its own mailing list, if you have questions please
      email the <a
-    href="http://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a> mailing
+    href="https://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a> mailing
     list.  Commits to the compiler-rt SVN module are automatically sent to the
-    <a 
-  href="http://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
+    <a
+  href="https://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
     mailing list.</p>
 </div>
 </body>
 </html>

libclc/www/index.html

 <html>
 <head>
 <title>libclc</title>
 </head>
 <body>
 <h1>libclc</h1>
 <p>
 libclc is an open source, BSD/MIT dual licensed
 implementation of the library requirements of the
 OpenCL C programming language, as specified by the <a
-href="http://www.khronos.org/registry/cl/specs/opencl-1.1.pdf">OpenCL
+href="https://www.khronos.org/registry/OpenCL/specs/opencl-1.1.pdf">OpenCL
 1.1 Specification</a>.  The following sections of the specification
 impose library requirements:
 <ul>
 <li>6.1: Supported Data Types
 <li>6.2.3: Explicit Conversions
 <li>6.2.4.2: Reinterpreting Types Using as_type() and as_typen()
 <li>6.9: Preprocessor Directives and Macros
 <li>6.11: Built-in Functions
 <li>9.3: Double Precision Floating-Point
 <li>9.4: 64-bit Atomics
 <li>9.5: Writing to 3D image memory objects
 <li>9.6: Half Precision Floating-Point
 </ul>
 </p>
 
 <p>
-libclc is intended to be used with the <a href="http://clang.llvm.org/">Clang</a>
+libclc is intended to be used with the <a href="https://clang.llvm.org/">Clang</a>
 compiler's OpenCL frontend.
 </p>
 
 <p>
 libclc is designed to be portable and extensible.  To this end,
 it provides generic implementations of most library requirements,
 allowing the target to override the generic implementation at the
 granularity of individual functions.
 </p>
 
 <p>
 libclc currently supports the AMDGCN, and R600 and NVPTX targets, but
 support for more targets is welcome.
 </p>
 
 <h2>Download</h2>
 
 <tt>git clone https://github.com/llvm/llvm-project.git</tt> (<a href="https://github.com/llvm/llvm-project/tree/libclc">View sources</a>)
 
 <h2>Mailing List</h2>
 
[e-mail] (<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/libclc-dev">subscribe/unsubscribe</a>, <a href="http://lists.llvm.org/pipermail/libclc-dev/">archives</a>)
[e-mail] (<a href="https://lists.llvm.org/cgi-bin/mailman/listinfo/libclc-dev">subscribe/unsubscribe</a>, <a href="https://lists.llvm.org/pipermail/libclc-dev/">archives</a>)
 
 </body>
 </html>

libcxx/www/index.html

<div id="content">
   <!--*********************************************************************-->
   <h1>"libc++" C++ Standard Library</h1>
   <!--*********************************************************************-->
 
   <p>libc++ is an implementation of the C++ standard library, targeting
      C++11, C++14 and above.</p>
 
   <p>All of the code in libc++ is <a
-     href="https://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+     href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">dual licensed</a>
      under the MIT license and the UIUC License (a BSD-like license).</p>
 
   <!--=====================================================================-->
   <h2>New Documentation Coming Soon!</h2>
   <!--=====================================================================-->
 
   <p> Looking for documentation on how to use, build and test libc++? If so
       checkout the new libc++ documentation.</p>

libcxxabi/www/index.html

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>"libc++abi" C++ Standard Library Support</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
     <label>libc++abi Info</label>
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://libcxx.llvm.org/">libc++</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/libcxx-commits">libcxx-commits</a>
-    <a href="http://llvm.org/bugs/">Bug Reports</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/libcxx-commits">libcxx-commits</a>
+    <a href="https://bugs.llvm.org/">Bug Reports</a>
     <a href="https://github.com/llvm/llvm-project/tree/master/libcxxabi/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>"libc++abi" C++ Standard Library Support</h1>
   <!--*********************************************************************-->
 
   <p>libc++abi is a new implementation of low level support for a standard
      C++ library.</p>
 
   <p>All of the code in libc++abi is <a
-     href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+     href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">dual licensed</a>
      under the MIT license and the UIUC License (a BSD-like license).</p>
 
   <!--=====================================================================-->
   <h2 id="goals">Features and Goals</h2>
   <!--=====================================================================-->
 
     <ul>
         <li>Correctness as defined by the C++11 standard.</li>
-        <li>Provide a portable sublayer to ease the porting of <a href="http://libcxx.llvm.org/">libc++</a></li>
+        <li>Provide a portable sublayer to ease the porting of <a href="https://libcxx.llvm.org/">libc++</a></li>
         <li>On Mac OS X, be ABI compatible with the existing low-level support.</li>
     </ul>
 
   <!--=====================================================================-->
   <h2 id="requirements">Platform Support</h2>
   <!--=====================================================================-->
 
    <p>libc++abi is known to work on the following platforms, using clang.</p>
<div id="content">
   <ul>
   <li><code>make check-cxxabi</code></li>
   </ul>
   <p>Note: in a standalone build, the system's libc++ will be used for tests. If
   the system's libc++ was statically linked against libc++abi (or linked against
   a different ABI library), this may interfere with test results.</p>
 
   <p>Send discussions to the
-  (<a href="http://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev mailing list</a>).</p>
+  (<a href="https://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev mailing list</a>).</p>
 
   <!--=====================================================================-->
   <h2>Frequently asked questions</h2>
   <!--=====================================================================-->
 
   <p>Q: Why are the destructors for the standard exception classes defined in libc++abi?
      They're just empty, can't they be defined inline?</p>
   <p>A: The destructors for them live in libc++abi because they are "key" functions.
      The Itanium ABI describes a "key" function as the first virtual declared.
      And wherever the key function is defined, that is where the <code>type_info</code> gets defined.
      And in libc++ types are the same type if and only if they have the same <code>type_info</code>
      (as in there must be only one type info per type in the entire application).
      And on OS X, libstdc++ and libc++ share these exception types.
-     So to be able to throw in one dylib and catch in another (a <code>std::exception</code> for example), 
+     So to be able to throw in one dylib and catch in another (a <code>std::exception</code> for example),
      there must be only one <code>std::exception type_info</code> in the entire app.
      That typeinfo gets laid down beside <code>~exception()</code> in libc++abi (for both libstdc++ and libc++).</p>
      <p>--Howard Hinnant</p>
 
 </div>
 </body>
 </html>

libcxxabi/www/spec.html

 
 <tr>
 <td  colspan=4 align="center">Exception Handling</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_throw(void* thrown_exception, struct std::type_info * tinfo, 
+<code>void __cxa_throw(void* thrown_exception, struct std::type_info * tinfo,
                         void (*dest)(void*));</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>

 </p>
 <blockquote>
 <p>
 <i>Effects:</i> Increments the ownership count of the currently handled
 exception (if any) by one.
 </p>
 <p>
 <i>Returns:</i> the type of the currently handled exception, or null if there
-are no caught exceptions.  
+are no caught exceptions.
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 

 
 <tr>
 <td colspan=4 align="center">Vector construction and destruction</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void* __cxa_vec_new(size_t element_count, 
-               size_t element_size, 
-                           size_t padding_size, 
+<code>void* __cxa_vec_new(size_t element_count,
+               size_t element_size,
+                           size_t padding_size,
                void (*constructor)(void*),
                void (*destructor)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 <p>
 <i>Returns:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
 <code>void* __cxa_vec_new2(size_t element_count,
-                size_t element_size, 
+                size_t element_size,
                             size_t padding_size,
                 void  (*constructor)(void*),
                 void  (*destructor)(void*),
-                            void* (*alloc)(size_t), 
+                            void* (*alloc)(size_t),
                             void  (*dealloc)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 <p>
 <i>Returns:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
 <code>void* __cxa_vec_new3(size_t element_count,
-                size_t element_size, 
+                size_t element_size,
                             size_t padding_size,
                 void  (*constructor)(void*),
                 void  (*destructor)(void*),
-                            void* (*alloc)(size_t), 
+                            void* (*alloc)(size_t),
                             void  (*dealloc)(void*, size_t) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 <p>
 <i>Returns:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_ctor(void*  array_address, 
+<code>void __cxa_vec_ctor(void*  array_address,
                            size_t element_count,
-                           size_t element_size, 
+                           size_t element_size,
                void (*constructor)(void*),
                void (*destructor)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_dtor(void*  array_address, 
+<code>void __cxa_vec_dtor(void*  array_address,
                            size_t element_count,
-               size_t element_size, 
+               size_t element_size,
                void (*destructor)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_cleanup(void* array_address, 
+<code>void __cxa_vec_cleanup(void* array_address,
                              size_t element_count,
-                             size_t element_size, 
+                             size_t element_size,
                  void (*destructor)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_delete(void*  array_address, 
-                             size_t element_size, 
-                             size_t padding_size, 
+<code>void __cxa_vec_delete(void*  array_address,
+                             size_t element_size,
+                             size_t padding_size,
                  void  (*destructor)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_delete2(void* array_address, 
-                             size_t element_size, 
-                             size_t padding_size, 
+<code>void __cxa_vec_delete2(void* array_address,
+                             size_t element_size,
+                             size_t padding_size,
                  void  (*destructor)(void*),
                              void  (*dealloc)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_delete3(void* __array_address, 
-                             size_t element_size, 
-                             size_t padding_size, 
+<code>void __cxa_vec_delete3(void* __array_address,
+                             size_t element_size,
+                             size_t padding_size,
                  void  (*destructor)(void*),
                void  (*dealloc) (void*, size_t));</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>void __cxa_vec_cctor(void*  dest_array, 
-              void*  src_array, 
-              size_t element_count, 
-              size_t element_size, 
-              void  (*constructor) (void*, void*), 
+<code>void __cxa_vec_cctor(void*  dest_array,
+              void*  src_array,
+              size_t element_count,
+              size_t element_size,
+              void  (*constructor) (void*, void*),
               void  (*destructor)(void*) );</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i>
 </p>
 </blockquote>
 </td>

 <tr>
 <td>
 <p>
 <code>void __cxa_call_unexpected (void*) __attribute__((noreturn));</code>
 </p>
 <blockquote>
 <p>
 <i>Effects:</i> Handles re-checking the exception specification if
-unexpectedHandler throws, and if <tt>bad_exception</tt> needs to be thrown. 
+unexpectedHandler throws, and if <tt>bad_exception</tt> needs to be thrown.
 Called from the compiler.
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 <tr>
 <td>
 <p>
-<code>char* __cxa_demangle(const char* mangled_name, 
+<code>char* __cxa_demangle(const char* mangled_name,
               char*       output_buffer,
-              size_t*     length, 
+              size_t*     length,
               int*        status);</code>
 </p>
 <blockquote>
 <p>
-<i>Effects:</i> 
+<i>Effects:</i>
 </p>
 <p>
 <i>Returns:</i>
 </p>
 </blockquote>
 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>

 </td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 <td>&#10003;</td>
 </tr>
 
 </table>
 
-<!-- 
+<!--
 000000000000d570 (__DATA,__const) external typeinfo for char32_t
 000000000000cfd0 (__DATA,__const) external typeinfo for std::nullptr_t
 000000000000d520 (__DATA,__const) external typeinfo for char16_t
 000000000000d580 (__DATA,__const) external typeinfo for char32_t*
 000000000000cfe0 (__DATA,__const) external typeinfo for std::nullptr_t*
 000000000000d530 (__DATA,__const) external typeinfo for char16_t*
 000000000000d5a0 (__DATA,__const) external typeinfo for char32_t const*
 000000000000d000 (__DATA,__const) external typeinfo for std::nullptr_t const*

openmp/www/index.html

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>OpenMP* : Support for the OpenMP language</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
     <label>OpenMP Info</label>
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/openmp-dev">openmp-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/openmp-commits">openmp-commits</a>
-    <a href="http://llvm.org/bugs/">Bug Reports</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/openmp-dev">openmp-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/openmp-commits">openmp-commits</a>
+    <a href="https://bugs.llvm.org/">Bug Reports</a>
     <a href="https://github.com/llvm/llvm-project/tree/master/openmp">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>OpenMP&reg;: Support for the OpenMP language</h1>
   <!--*********************************************************************-->
<div id="content">
 
   <p>Support for the parts of the OpenMP 4.0 (and later) language that are not
   associated with the "target" constructs are contained in the
   "runtime" directory. Support for offloading computation via the
   "target" directive is in the separate "libomptarget" directory.
   </p>
 
   <p>All of the code here is <a
-     href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+     href="https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents">dual licensed</a>
      under the MIT license and the UIUC License (a BSD-like license).
      The LICENSE.txt file at the top of the OpenMP project contains
      the license text and associated patent grants.
   </p>
 
   <!--=====================================================================-->
   <h2 id="dir-structure">Status</h2>
   <!--=====================================================================-->
 
    <p>With the release of Clang 3.8.0, OpenMP 3.1 support is enabled in
    Clang by default, and the OpenMP runtime is therefore built as a
    normal part of the Clang build, and distributed with the binary
    distributions.You do not, therefore, need explicitly to check out this code, or
    build it out of tree; a normal Clang check out and build will
    automatically include building these runtime libraries.
    </p>
 
   <!--=====================================================================-->
   <h2 id="goals">Features and Goals</h2>
   <!--=====================================================================-->
 
     <ul>
-        <li>Support for the <a href="http://www.openmp.org/mp-documents/OpenMP3.1.pdf">OpenMP
+        <li>Support for the <a href="https://www.openmp.org/wp-content/uploads/OpenMP3.1.pdf">OpenMP
           3.1 standard (PDF)</a> has been achieved in the Clang 3.8.0
           release.
         </li>
 
         <li>Support for the
- <a href="http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf">OpenMP
-          4.0 standard (PDF)</a> and <a href="http://www.openmp.org/mp-documents/OpenMP4.5.pdf">OpenMP
+ <a href="https://www.openmp.org/wp-content/uploads/OpenMP4.0.0.pdf">OpenMP
+          4.0 standard (PDF)</a> and <a href="https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf">OpenMP
           4.5 standard (PDF)</a> is now being implemented. (Some OpenMP 4.0
           and 4.5 features are already available).
         <li>High performance.</li>
-        <li>ABI compatibility with <a href="http://gcc.gnu.org">Gcc</a> and
-        <a href="http://software.intel.com/en-us/intel-compilers">Intel's
+        <li>ABI compatibility with <a href="https://gcc.gnu.org">Gcc</a> and
+        <a href="https://software.intel.com/en-us/compilers">Intel's
         existing OpenMP compilers.</a>
         We currently have binary compatibility with OpenMP
         3.1 code compiled by gcc 4.9, however we do not have support
         for OpenMP 4.0 code that uses task cancellation when compiled
         by gcc 4.9. How we will support such code remains a research issue.
         </li>
     </ul>
 
<a href="https://www.openmp.org/wp-content/uploads/OpenMP4.0.0.pdf">OpenMP
   </p>
 
 
   <!--=====================================================================-->
   <h2>Get it and get involved!</h2>
   <!--=====================================================================-->
 
   <p>First please review our
-     <a href="http://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
+     <a href="https://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
 
   <p>To check out the code, use:</p>
 
   <ul>
   <li><code>git clone https://github.com/llvm/llvm-project.git</code></li>
   </ul>
 
   <p>In-tree build:</p>
<a href="https://www.openmp.org/wp-content/uploads/OpenMP4.0.0.pdf">OpenMP
   <h3>Notes</h3>
   <!--=====================================================================-->
 
 <p>
 
 </p>
 
   <p>Send discussions to the
-  (<a href="http://lists.llvm.org/mailman/listinfo/openmp-dev">OpenMP mailing list</a>).</p>
+  (<a href="https://lists.llvm.org/mailman/listinfo/openmp-dev">OpenMP mailing list</a>).</p>
 
 
   <!--=====================================================================-->
   <h2>Design Documents</h2>
   <!--=====================================================================-->
 
 <ul>
 <li><a href="Reference.pdf">Runtime design (PDF)</a></li>

polly/www/changelog.html

 <li>Accesses to multi-dimensional arrays of fixed size are within bounds</li>
 </ul>
 <li>Compile-time reduction</li>
 </ul>
 
 <h2> Older releases</h2>
 
 No changelog available. Please look at the <a
-href="http://repo.or.cz/w/polly-mirror.git">commit history</a>.
+href="https://repo.or.cz/w/polly-mirror.git">commit history</a>.
 
 </html>
 </div>
 </body>
 </html>

polly/www/documentation.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>Polly - Documentation</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">

polly/www/get_started.html

 
 There is a <a href="polly.sh">script</a> available to automatically checkout,
 update, build, and test Polly. This script contains all the commands that are
 subsequently described on this webpage. The automatic installation consists
 of four simple steps:
 
 <pre>
 mkdir polly &amp;&amp; cd polly
-wget http://polly.llvm.org/polly.sh
+wget https://polly.llvm.org/polly.sh
 chmod +x polly.sh
 ./polly.sh
 </pre>
 
 <h2> Manual </h2>
 <h3 id="source"> Get the code </h3>
 
 <pre>
-git clone http://github.com/llvm/llvm-project.git llvm_git
+git clone https://github.com/llvm/llvm-project.git llvm_git
 </pre>
 <h3 id="build">Build Polly</h3>
 
 <pre>
 mkdir llvm_build && cd llvm_build
 cmake -DLLVM_ENABLE_PROJECTS='polly;clang' ../llvm_git/llvm && make
 </pre>
 

polly/www/index.html

<div id="content">
   program. We currently perform classical loop transformations, especially
   tiling and loop fusion to improve data-locality. Polly can also exploit
   OpenMP level parallelism, expose SIMDization opportunities. Work has also be
   done in the area of automatic GPU code generation.</p>
 
   For many users, however, it's not the existing optimizations in Polly that are
   of most interest, but the new analyses and optimizations enabled by the Polly
   infrastructure. At
-  <a href="http://polyhedral.info">polyhedral.info</a> you can get an idea of
+  <a href="https://polyhedral.info">polyhedral.info</a> you can get an idea of
   what has already been done and what is possible in the context of polyhedral
   compilation.
 
   <!--=====================================================================-->
   <h2>News</h2>
   <!--=====================================================================-->
 
   <table id="news">
<div id="content">
   </td>
   </tr>
   <tr><td><b>2014</b></td></tr>
   <tr><td width="120"><p>June</p></td>
   <td>
   <h4>Polly can be built without GPL licensed software</h4> After Sebastian
   Pop's
   and David Peixotto's (both Qualcomm) recent <a
-  href="http://repo.or.cz/w/isl.git/commit/60703e3ee89b9d5d4d1afb6a3f611292c0884574">commit</a>
+  href="https://repo.or.cz/w/isl.git/commit/60703e3ee89b9d5d4d1afb6a3f611292c0884574">commit</a>
   to isl, isl's latest development version can be built with imath instead of
   GMP. With both CLooG and gmp having become optional, the last obilgatory
   dependency to GPL licensed software has been removed. Now Polly only depends
   on isl (and the included imath), which are both MIT licensed.
   </td>
   </tr>
   <tr><td width="120"><p>April</p></td>
   <td>
<div id="content">
   <h4>Polly presentation at FOSDEM 2014</h4> Polly was <a
   href="https://fosdem.org/2014/schedule/event/polly/">presented</a> at the
   FOSDEM LLVM developer's meeting.
   <h4>New LLVM test-suite buildbots</h4>
   The set of <a href="http://lab.llvm.org:8011/console?category=polly">Polly
   buildbots</a> has been extended. We now have 16 new blades that track
   correctness and performance when compiling the LLVM test-suite. For now five
   of them are used to provide <a
-  href="http://llvm.org/perf/db_default/v4/nts/22463">fine granularity
+  href="https://llvm.org/perf/db_default/v4/nts/22463">fine granularity
   reports</a> (almost per-commit)
   for 'clang -O3' (no polly). We also have six machines that track different
   configurations of polly.
   </td>
   </tr>
   <tr><td width="120"><p>January</p></td>
   <td>
   <h4>islplot released</h4>
   <a href="https://github.com/tobig/islplot">islplot</a> is a library that
   generates illustrations of integer sets and maps. It relies on <a
-  href="http://repo.or.cz/w/isl.git">isl</a> to model the integer sets and uses the <a
+  href="https://repo.or.cz/w/isl.git">isl</a> to model the integer sets and uses the <a
   href="https://pypi.python.org/pypi/islpy">islpy</a> Python bindings to access
   them. Plotting is performed with <a
-  href="http://matplotlib.org">matplotlib</a>. The following <a
-  href="http://nbviewer.ipython.org/github/tobig/islplot/blob/master/notebooks/islplot-examples.ipynb">
+  href="https://matplotlib.org">matplotlib</a>. The following <a
+  href="https://nbviewer.ipython.org/github/tobig/islplot/blob/master/notebooks/islplot-examples.ipynb">
   Examples</a> show its use.
   </td>
   </tr>
   <tr><td><b>2013</b></td></tr>
   <tr><td width="120"><p>November</p></td>
   <td>
   <h4>Loop optimization BoF at upcoming LLVM conference</h4>
-  At the upcoming <a href="http://llvm.org/devmtg/2013-11/#bof5">LLVM conference
+  At the upcoming <a href="https://llvm.org/devmtg/2013-11/#bof5">LLVM conference
   </a> there will be a loop optimization BoF discussing Polly and other high
   level loop optimizers.
   </td>
   </tr>
   <tr><td width="120"><p>October</p></td>
   <td>
   <h4>Automatic code coverage and static analysis tests</h4>
   Sylvestre Ledru set up automatic tests for <a
-  href="http://llvm.org/reports/coverage/">code coverage</a> and
-  <a href="http://llvm.org/reports/scan-build/">static analysis</a>
+  href="https://llvm.org/reports/coverage/">code coverage</a> and
+  <a href="https://llvm.org/reports/scan-build/">static analysis</a>
   which run at least once a day and which include results for Polly.
   <h4>Move to CLooG 0.18.1 and isl 0.12.1</h4>
   With the move to an isl 0.12 version Polly can be compiled without the
   need to link directly to GMP (if isl is used for code generation). Currently
   isl is still internally using GMP, but private patches exist to also remove
   this dependency. Without the use of GMP, a <b>GPL free</b> version of Polly
   is possible.
   </td></tr>
research tool.<br \>
   following week of joint work at IISC Bangalore and in cooperation with
   AMD India.
   </td></tr>
   <td>
   </td></tr>
   <tr><td width="120"><p>February</p></td>
   <td>
   <p>Polly is an official LLVM project, reachable at <a
-  href="http://polly.llvm.org">http://polly.llvm.org</a></p>
+  href="https://polly.llvm.org">https://polly.llvm.org</a></p>
   </td></tr>
   <tr><td width="120"><p>January</p></td>
   <td>
   <p>Improved support for the isl scheduling optimizer</p>
   Polly can now automatically optimize all <a
-  href="http://www.cse.ohio-state.edu/~pouchet/software/polybench/">polybench
+  href="https://web.cse.ohio-state.edu/~pouchet.2/software/polybench/">polybench
   2.0</a> kernels without the help of
   an external optimizer. The compile time is reasonable and we can show
   notable speedups for various kernels.
   </td></tr>
 
   <tr>
   <tr><td><b><br/>2011</b></td></tr>
   <tr><td width="120"><p>November</p></td>
   <td>
   <p>
-  Talk at the <a href="http://llvm.org/devmtg/2011-11/">
+  Talk at the <a href="https://llvm.org/devmtg/2011-11/">
       LLVM Developer Meeting 2011</a></p>
   New SCEV parser<br>
   (Allows parameters in array subscript and max/signextend)
   </td></tr>
 
   <tr>
   <td><p>October</p></td>
   <td>
research tool.<br \>
   <tr>
   <td><p> Dezember </p></td>
   <td><p>Basic vectorization support </p></td>
   </tr>
 
   <tr>
   <td><p> November </p></td>
   <td><p>Talk at the <a
-  href="http://llvm.org/devmtg/2010-11/">LLVM Developer Meeting</a> </p></td>
+  href="https://llvm.org/devmtg/2010-11/">LLVM Developer Meeting</a> </p></td>
   </tr>
 
   <tr>
   <td><p>October</p></td>
   <td><p>Dependency analysis </p>
   <p>Finished Phase 1 - Get something working </p>
   <p>Support scalar dependences and sequential SCoPs </p>
   </td>

polly/www/performance.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head> <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>Polly - Performance</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 <body>
 <div id="box">
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
 <h1>Performance</h1>
 
 <p>To evaluate the performance benefits Polly currently provides we compiled the
-<a href="http://www.cse.ohio-state.edu/~pouchet/software/polybench/">Polybench
+<a href="https://web.cse.ohio-state.edu/~pouchet.2/software/polybench/">Polybench
 2.0</a> benchmark suite.  Each benchmark was run with double precision floating
 point values on an Intel Core Xeon X5670 CPU @ 2.93GHz (12 cores, 24 thread)
 system. We used <a href="http://pocc.sf.net">PoCC</a> and the included <a
 href="http://pluto-compiler.sf.net">Pluto</a> transformations to optimize the
-code. The source code of Polly and LLVM/clang was checked out on 
+code. The source code of Polly and LLVM/clang was checked out on
 25/03/2011.</p>
 
 <p>The results shown were created fully automatically without manual
 interaction. We did not yet spend any time to tune the results. Hence
 further improvments may be achieved by tuning the code generated by Polly, the
 heuristics used by Pluto or by investigating if more code could be optimized.
 As Pluto was never used at such a low level, its heuristics are probably
 far from perfect. Another area where we expect larger performance improvements

polly/www/phonecall.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   <title>Polly - Polyhedral Phone Call</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 <body>
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
   <!--*********************************************************************-->
   <h1>Polly: Polyhedral Phone Call</h1>
   <!--*********************************************************************-->
 
   <p>There are irregular phone calls to discuss polyhedral topics and
      related projects. For this we use a conference service that can be
      reached both through SIP clients and international dial in numbers.</p>
 
  <ul>
  <li><b>VoIP/SIP:</b> sip:[e-mail]<br />
-    <a href="http://ekiga.org">Ekiga</a> is a SIP client that works well for
+    <a href="https://www.ekiga.org">Ekiga</a> is a SIP client that works well for
     most of us.</li>
- <li><b>Traditional Dailin Numbers:</b><br />
+ <li><b>Traditional Dial In Numbers:</b><br />
     To use your normal land line phone to connect to the conference dial
     one of the many available <a
     href="http://www.sipbroker.com/sipbroker/action/pstnNumbers">dial in
     numbers</a>. When asked for the number to connect type: <em>*011497659</em>.
     <br />
-    Attention: Some of the dial in numbers do not work reliable. If you are not
+    Attention: Some of the dial in numbers do not work reliably. If you are not
     asked for the number you want to connect to after a couple of seconds, just
     try another one. <br/>
     Some selected dial in numbers:
     <ul>
     <li><b>USA:</b> [phone], [phone] </li>
     <li><b>UK:</b> [phone], [phone]</li>
     <li><b>Belgium:</b> [phone], [phone]</li>
     </ul>
 
-    </ul> 
-  
+    </ul>
 </div>
 </body>
 </html>

polly/www/projects.html

<div id="content">
 
   LLVM Polly keeps here a list of open projects which each of themselves would
   be a great contribution to Polly. All of these projects are meant to be self
   contained and should take a newcomer around 3-4 months of work. The projects
   we propose are all suiteable as <a
   href="https://developers.google.com/open-source/gsoc/">Google Summer of
   Code</a> projects. In case you are interested in a Google Summer of code
   project make sure to reach out via the Polly <a
-  href="http://groups.google.com/group/polly-dev">mailing list</a> early to
+  href="https://groups.google.com/group/polly-dev">mailing list</a> early to
   discuss your project proposal.
 
   <h3>Integrate Polly with the LLVM vectorizers</h3>
   Polly is not only a self-contained optimizer, but also provides a powerful
   dependence and other program analyses. Currently, these analyses are only used
   for our own optimizations. However, LLVM passes such as the loop vectorizer
   would clearly benefit from having direct access to the available Polly
   analyses. In this project, you would define in collaboration with the LLVM
<div id="content">
   magnitude off. In this project you will investigate what is needed to close
   this performance gap. Earlier investigations have shown that register tiling
   is one important piece towards this goal. In combination with good tile size
   models and some back-end work, this project is shooting to make common blas
   operations, but also many non-blas kernels competitive with vendor math
   libraries and outperforming the code icc/gcc currently generate.
 
   <h3>Polly support for Julia - First steps</h3>
-  <a href="http://julialang.org/">Julia</a> is a new matlab style programming
+  <a href="https://julialang.org/">Julia</a> is a new matlab style programming
   language that provides C like performance for scientific computing. Even
   though Julia also translates to LLVM-IR, parsing and optimizing Julia code
   poses new challenges that currently prevent Polly from optimizing Julia
   code despite the clear need for optimizations such as loop-tiling for Julia.
   In this project you will -- starting from first proof-of-concept patches --
   integrate Polly into Julia and ensure that Julia code can benefit from the
   same high-level loop optimizations as todays C code already does. If time
   permits, making Polly's recent bound-check elimination logic work in Julia

polly/www/publications.html

 <div id="box">
 <!--#include virtual="menu.html.incl"-->
 <div id="content">
   <!--*********************************************************************-->
   <h1>Publications</h1>
   <!--*********************************************************************-->
 
   <h2> Publications about polyhedral compilation </h2>
-  <a href="http://polyhedral.info/publications.html">polyhedral.info</a> has a
+  <a href="https://polyhedral.info/publications.html">polyhedral.info</a> has a
   large list of publications related to polyhedral compilation. They are very
   useful to get an idea of the latest developments in this area of compilation
   as well as to understand what kind of optimizations can be built on top of
   Polly.
 
   <h2> Citing Polly</h2>
 
   The canonical publication to cite Polly is:
 
 <p>
   <em>Polly - Performing polyhedral optimizations on a low-level intermediate
       representation </em><br />
 Tobias Grosser, Armin Groesslinger, Christian Lengauer<br />
 Parallel Processing Letters 2012 22:04<br />
   <a href="http://www.grosser.es#pub-Polly">Paper</a>
 </p>
 
   <h2> Publications involving Polly </h2>
   <h3> 2016 </h3>
   <ul>
   <li><em>Loopy: Programmable and Formally Verified Loop Transformations</em><br />
   Kedar Namjoshi and Nimit Singhania<br />
   23rd Static Analysis Symposium (SAS 2016)<br />
-  <a href="http://link.springer.com/chapter/10.1007/978-3-662-53413-7_19">Paper</a>
+  <a href="https://link.springer.com/chapter/10.1007/978-3-662-53413-7_19">Paper</a>
   </li>
   <li><em>Input Space Splitting for OpenCL</em><br />
   Simon Moll, Johannes Doerfert and Sebastian Hack<br />
   25th International Conference on Compiler Construction (CC 2016)<br />
   </li>
   <li><em>Parallelisation automatique de programmes scientifiques pour systems
   distribues
   </em><br />
</p>
   href="publications/kernelgen-pavt-2012-slides.pdf">Slides</a>
   </li>
   </ul>
   <h3> 2011 </h3>
   <ul>
   <li><em>Polly - First Successful Optimizations - How to proceed?</em><br />
   Tobias Grosser, Ragesh A<br />
   LLVM Developer Meeting 2011<br /><a
-  href="http://llvm.org/devmtg/2011-11/Grosser_PollyOptimizations.pdf">Slides</a>, <a
-  href="http://llvm.org/devmtg/2011-11/videos/Grosser_PollyOptimizations-desktop.mov">Video
+  href="https://llvm.org/devmtg/2011-11/Grosser_PollyOptimizations.pdf">Slides</a>, <a
+  href="https://llvm.org/devmtg/2011-11/videos/Grosser_PollyOptimizations-desktop.mov">Video
   (Computer)</a>, <a
-  href="http://llvm.org/devmtg/2011-11/videos/Grosser_PollyOptimizations-mobile.mp4">Video
+  href="https://llvm.org/devmtg/2011-11/videos/Grosser_PollyOptimizations-mobile.mp4">Video
   (Mobile)</a></li>
   <li><em>A Framework for Automatic OpenMP Code Generation</em><br />
   Raghesh A<br />
   Masters Thesis (May 2011)<br />
   <a
   href="publications/raghesh-a-masters-thesis.pdf">Thesis</a>
   </li>
   <li><em>Enabling Polyhedral Optimizations in LLVM</em><br />
</p>
   href="publications/grosser-impact-2011-slides.pdf">Slides </a>
   </li>
   </ul>
   <h3> 2010 </h3>
   <ul>
   <li><em>Polly - Polyhedral Transformations for LLVM</em><br />
   Tobias Grosser, Hongbin Zheng<br />
   LLVM Developer Meeting 2010<br /><a
-  href="http://llvm.org/devmtg/2010-11/Grosser-Polly.pdf">Slides</a>, <a
-  href="http://llvm.org/devmtg/2010-11/videos/Grosser_Polly-desktop.mp4">Video
+  href="https://llvm.org/devmtg/2010-11/Grosser-Polly.pdf">Slides</a>, <a
+  href="https://llvm.org/devmtg/2010-11/videos/Grosser_Polly-desktop.mp4">Video
   (Computer)</a>, <a
-  href="http://llvm.org/devmtg/2010-11/videos/Grosser_Polly-mobile.mp4">Video
+  href="https://llvm.org/devmtg/2010-11/videos/Grosser_Polly-mobile.mp4">Video
   (Mobile)</a></li>
   </ul>
 
   <h2>Publications used within Polly</h2>
   <h3>Polyhedral library</h3>
   <ul>
   <li><em>isl: An Integer Set Library for the Polyhedral Model </em><br />
   Sven Verdoolaege<br />

polly/www/todo.html

 </td></tr>
 <tr>
 <th align="left">
 Code generate PHI dependences
 </th><td align="center" class='done'> Done
 </td><td>
 </td></tr>
 <tr>
-<th align="left"> <a href="http://llvm.org/bugs/show_bug.cgi?id=12398">Remove
+<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12398">Remove
 the need for independent blocks</a>
 </th><td class="done"> Done
 </td><td>
 </td></tr>
 <tr>
 <th align="left">
 Remove polly-prepare pass
 </th><td align="center" class='open'> Open
 </td><td>
 </td></tr>
 
 <tr><td colspan='4'>&nbsp;</td></tr>
 <tr><th colspan="3" style="background: rgb(239, 239, 239);"> Correctness in
 cornercases </th></tr>
 <tr style="background: rgb(239, 239, 239)">
   <th width="400px"> Task </th>
   <th width="150px"> Status </th>
   <th> Owner </th>
 </tr>
 <tr>
-<th align="left"> <a href="http://llvm.org/bugs/show_bug.cgi?id=10381">Derive
+<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=10381">Derive
 optimal types (instead of always using i64)</a>
 </th><td class="open"> Open
 </td><td>
 </td></tr>
 <tr>
-<th align="left"> <a href="http://llvm.org/bugs/show_bug.cgi?id=12397">Model
+<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12397">Model
 integer wrapping</a>
 </th><td align="center" class='done'> Done
 </td><td> Johannes
 </td></tr
 
 <tr><td colspan='4'>&nbsp;</td></tr>
 <tr><th colspan="3" style="background: rgb(239, 239, 239);"> Optimize Julia
 code with Polly

 </td><td>Marcello
 </td>
 </tr>
 
 
 <tr>
 <tr>
 <th align="left"> <a
-href="http://llvm.org/bugs/show_bug.cgi?id=12403">Variable-size
+href="https://bugs.llvm.org/show_bug.cgi?id=12403">Variable-size
 multi-dimensional arrays</a>
 </th><td align="center" class='done'> Done
 </td><td>Sebastian
 </td></tr>
 <tr>
 <th align="left"> <a
-href="http://llvm.org/bugs/show_bug.cgi?id=12407">Derive information for
+href="https://bugs.llvm.org/show_bug.cgi?id=12407">Derive information for
 the SCoP context
 </a>
 </th>
 <td align="center" class='nice'> Open
 </td><td>
 </td></tr>
 <tr>
-<th align="left"> <a href="http://llvm.org/bugs/show_bug.cgi?id=12402">Finer
+<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12402">Finer
 grained statements</a>
 </th><td align="center" class='nice'> Open
 </td><td>
 </td></tr>
 <tr>
 <th align="left"> Detect reductions
 </th><td align="center" class='done'>Done
 </td><td>Johannes

 <tr><td colspan='4'>&nbsp;</td></tr>
 <tr><th colspan="3" style="background: rgb(239, 239, 239);"> Optimizer </th></tr>
 <tr style="background: rgb(239, 239, 239)">
   <th width="400px"> Task </th>
   <th width="150px"> Status </th>
   <th> Owner </th>
 </tr>
 <tr>
-<th align="left"> <a href="http://llvm.org/bugs/show_bug.cgi?id=12405">Polyhedral
+<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12405">Polyhedral
 dead code elimination</a>
 </th><td class="done">Done
 </td><td>
 </td></tr>
 
 <tr><td colspan='4'>&nbsp;</td></tr>
 <tr><th colspan="3" style="background: rgb(239, 239, 239);"> Back End</th></tr>
 <tr style="background: rgb(239, 239, 239)">
   <th width="400px"> Task </th>
   <th width="150px"> Status </th>
   <th> Owner </th>
 </tr>
 <tr>
 <th align="left"> OpenMP code generation support in isl backend
 (requirement to drop CLooG)
 </th><td class="done"> Done
 </td><td> Tobias
 </td></tr>
 <tr>
 <th align="left"> Run-time alias checks
 </th><td class="done"> Done
 </td><td>Johannes
 <tr>
 <th align="left"> <a
-href="http://polly.llvm.org/documentation/gpgpucodegen.html">GPGPU Code
+href="https://polly.llvm.org/documentation/gpgpucodegen.html">GPGPU Code
 Generation</a>
 </th><td class="niceinprogress">in progress
 </td><td>
 Yabin
 </td></tr>
 <tr>
 <th align="left"> <a
-href="http://polly.llvm.org/documentation/memaccess.html">Allow optimizers to
+href="https://polly.llvm.org/documentation/memaccess.html">Allow optimizers to
 change memory access functions</a>
 </th><td class="done"> Done
 </td><td>Johannes
 </td></tr>
 <tr>
-<th align="left"> <a href="http://llvm.org/bugs/show_bug.cgi?id=12406">Make code
+<th align="left"> <a href="https://bugs.llvm.org/show_bug.cgi?id=12406">Make code
 generation independent of the clast</a>
 </th><td class="done">Done
 </td><td>
 </td></tr>
 
 <tr>
 <tr><td colspan='4'>&nbsp;</td></tr>
 <tr><th colspan="3" style="background: rgb(239, 239, 239);"> General</th></tr>
 <tr style="background: rgb(239, 239, 239)">
   <th width="400px"> Task </th>
   <th width="150px"> Status </th>
   <th> Owner </th>
 </tr>
 <tr>
 <th align="left"> Teach bugpoint to extract regions
 </th><td class="nice"> Open
 </td><td>
 </td></tr>
 <tr>
 <th align="left"> Add <a
-href="http://www.cse.ohio-state.edu/~pouchet/software/polybench/">Polybench
+href="https://web.cse.ohio-state.edu/~pouchet.2/software/polybench/">Polybench
 3.2</a> to the LLVM test suite
 </th><td class="done"> Done
 </td><td>
 </td></tr>
 <tr>
 <th align="left"> Build against an installed LLVM
 </th><td class="done"> Done<br />
 </td><td>

 <th>Task
 </th><th> Status
 </th><th>Owner
 </th></tr>
 <tr>
 <th align="left"> Move to LLVM SVN
 </th><td class="done" align="center">
 <a
-href="http://llvm.org/svn/llvm-project/polly"
->http://llvm.org/svn/llvm-project/polly</a>
+href="https://llvm.org/svn/llvm-project/polly"
+>https://llvm.org/svn/llvm-project/polly</a>
 </td><td> Tobias
 
 </td></tr>
 <tr>
 <th align="left"> Commit mails
 </th><td class="done" align="center">
 [e-mail]
 </td><td> Tobias
 </td></tr>
 <tr>
 
 <th align="left"> LLVM Bugzilla category
 </th><td class="done" align="center">
-<a href="http://llvm.org/bugs/enter_bug.cgi?product=Projects">LLVM Bugzilla</a>
+<a href="https://bugs.llvm.org/enter_bug.cgi?product=Projects">LLVM Bugzilla</a>
 <br />
 (Product is 'Projects', Component is 'Polly')
 </td><td> Tobias
 <tr>
 <th align="left"> Website
 </th><td class="done" align="center">
-<a href="http://polly.llvm.org">http://polly.llvm.org</a>
+<a href="https://polly.llvm.org">https://polly.llvm.org</a>
 </td><td> Tobias
 </td></tr>
 <tr>
 <th align="left">Buildbot that runs 'make polly-test'
 </th><td class="done" align="center">
 <a href="http://lab.llvm.org:8011/console">Buildbot</a>
 </td>
 <td> Tobias, Andreas