diff --git a/extensions/KHR/KHR_texture_compression_astc_hdr.txt b/extensions/KHR/KHR_texture_compression_astc_hdr.txt
index 2231337..9b4422d 100644
--- a/extensions/KHR/KHR_texture_compression_astc_hdr.txt
+++ b/extensions/KHR/KHR_texture_compression_astc_hdr.txt
@@ -946,7 +946,7 @@
             if Q[2:1] = 11
                 q2 = 4; C = { Q[4:3], ~Q[6:5], Q[0] }
             else
-                q2 = T[6:5]; C = Q[4:0]
+                q2 = Q[6:5]; C = Q[4:0]
 
             if C[2:0] = 101
                 q1 = 4; q0 = C[4:3]
diff --git a/extensions/OES/OES_texture_compression_astc.txt b/extensions/OES/OES_texture_compression_astc.txt
index bbdb5cc..0514f65 100644
--- a/extensions/OES/OES_texture_compression_astc.txt
+++ b/extensions/OES/OES_texture_compression_astc.txt
@@ -1065,7 +1065,7 @@
             if Q[2:1] = 11
                 q2 = 4; C = { Q[4:3], ~Q[6:5], Q[0] }
             else
-                q2 = T[6:5]; C = Q[4:0]
+                q2 = Q[6:5]; C = Q[4:0]
 
             if C[2:0] = 101
                 q1 = 4; q0 = C[4:3]
diff --git a/index_es.php b/index_es.php
index f13f93e..9d0066a 100644
--- a/index_es.php
+++ b/index_es.php
@@ -9,10 +9,11 @@
     OpenGL ES extensions; header files corresponding to the
     specifications; and related documentation. </p>
 
-<p> The OpenGL ES Registry is part of the combined <a
-    href="http://www.opengl.org/registry/"> OpenGL Registry </a> for OpenGL,
-    OpenGL ES, and OpenGL SC, which includes the <a href="xml/README.md">XML
-    API registry</a> of reserved enumerants and functions. </p>
+<p> The OpenGL ES Registry is part of the <a
+    href="http://www.khronos.org/registry/OpenGL/"> Combined OpenGL Registry </a>
+    for OpenGL, OpenGL ES, and OpenGL SC, which includes the <a
+    href="xml/README.md">XML API registry</a> of reserved enumerants and
+    functions. </p>
 
 <p> <b>Table of Contents</b>
 <ul>
@@ -67,8 +68,8 @@
 <li> OpenGL ES Shading Language 3.20 Specification (July 10, 2019)
      <a href="specs/es/3.2/GLSL_ES_Specification_3.20.html"> (HTML) </a>
      <a href="specs/es/3.2/GLSL_ES_Specification_3.20.pdf"> (PDF) </a>
-<li> <a href="http://www.khronos.org/opengles/sdk/docs/man32/">
-     OpenGL ES 3.2 Online Manual Pages.</a> </li>
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/es3/">
+     OpenGL ES 3.2 Online Reference Pages.</a> </li>
 <li> <a href="https://www.khronos.org/developers/reference-cards">
      OpenGL ES Quick Reference Card </a> (available for different API
      versions). </li>
@@ -86,8 +87,8 @@
      <a href="specs/es/3.1/GLSL_ES_Specification_3.10.pdf"> without changes marked </a>
      and
      <a href="specs/es/3.1/GLSL_ES_Specification_3.10.withchanges.pdf"> with changes marked </a>. </li>
-<li> <a href="http://www.khronos.org/opengles/sdk/docs/man31/">
-     OpenGL ES 3.1 Online Manual Pages.</a> </li>
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/es3.1/">
+     OpenGL ES 3.1 Online Reference Pages.</a> </li>
 </ul>
 
 <h2> <a name="specs3"></a> OpenGL ES 3.0 Specifications and
@@ -101,8 +102,8 @@
 <li> OpenGL ES Shading Language 3.00
      <a href="specs/es/3.0/GLSL_ES_Specification_3.00.pdf">
      Specification </a> (January 29, 2016). </li>
-<li> <a href="http://www.khronos.org/opengles/sdk/docs/man3/">
-     OpenGL ES 3.0 Online Manual Pages.</a> </li>
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/es3.0/">
+     OpenGL ES 3.0 Online Reference Pages.</a> </li>
 </ul>
 
 <h2> <a name="specs2"></a> OpenGL ES 2.0 Specifications and
@@ -123,8 +124,8 @@
 <li> OpenGL ES Shading Language 1.00
      <a href="specs/es/2.0/GLSL_ES_Specification_1.00.pdf">
      Specification </a> (May 12, 2009). </li>
-<li> <a href="http://www.khronos.org/opengles/sdk/docs/man/">
-     OpenGL ES 2.0 Online Manual Pages.</a> </li>
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/es2.0/">
+     OpenGL ES 2.0 Online Reference Pages.</a> </li>
 </ul>
 
 
@@ -139,8 +140,8 @@
      (April 24, 2008). </li>
 <li> <a href="specs/es/1.1/opengles_spec_1_1_extension_pack.pdf"> OpenGL ES
      1.1.03 Extension Pack </a> (July 19, 2005). </li>
-<li> <a href="http://www.khronos.org/opengles/sdk/1.1/docs/man/">
-     OpenGL ES 1.1 Online Manual Pages.</a> </li>
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/es1.1/">
+     OpenGL ES 1.1 Online Reference Pages.</a> </li>
 </ul>
 
 <h2> <a name="specs10"></a> OpenGL ES 1.0 Specification and
@@ -152,8 +153,8 @@
 <li> <tt><a href="api/GLES/1.0/gl.h"> gl.h </a></tt> for OpenGL ES 1.0. </li>
 <li> The old <i>OpenGL ES 1.0 and EGL 1.0 Reference Manual</i> is
      obsolete and has been removed from the Registry. Please use the
-     <a href="http://www.khronos.org/opengles/sdk/1.1/docs/man/">
-     OpenGL ES 1.1 Online Manual Pages</a> instead. </li>
+     <a href="http://www.khronos.org/registry/OpenGL-Refpages/es1.1/">
+     OpenGL ES 1.1 Online Reference Pages</a> instead. </li>
 </ul>
 
 <hr>
diff --git a/index_gl.php b/index_gl.php
index f7f4457..88d3cd5 100644
--- a/index_gl.php
+++ b/index_gl.php
@@ -10,10 +10,11 @@
     related documentation including specifications, extensions, and headers
     for the GLX, WGL, and GLU APIs. </p>
 
-<p> The OpenGL registry is part of the combined <a
-    href="http://www.opengl.org/registry/"> OpenGL Registry </a> for OpenGL,
-    OpenGL ES, and OpenGL SC, which includes the <a href="xml/README.md">XML
-    API registry</a> of reserved enumerants and functions. </p>
+<p> The OpenGL registry is part of the <a
+    href="http://www.khronos.org/registry/OpenGL/"> Combined OpenGL Registry </a>
+    for OpenGL, OpenGL ES, and OpenGL SC, which includes the <a
+    href="xml/README.md">XML API registry</a> of reserved enumerants and
+    functions. </p>
 
 <p> <b>Table of Contents</b>
 <ul>
@@ -65,7 +66,7 @@
      <a href="specs/gl/GLSLangSpec.4.60.html"> (HTML) </a> </li>
      <a href="specs/gl/GLSLangSpec.4.60.pdf"> (PDF) </a> </li>
 
-<li> <a href="http://www.opengl.org/sdk/docs/man4/"> OpenGL 4.5 API and
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/gl4/"> OpenGL 4.5 API and
      Shading Language Reference Pages </a> (not yet updated) </li>
 
 <li> <b> OpenGL X Window System Binding (GLX 1.4) Specification </b> </li>
@@ -181,10 +182,6 @@
 <li> <a href="specs/gl/GLSLangSpec.3.30.pdf"> OpenGL Shading Language
      3.30 Specification </a> </li>
 
-<li> <b> OpenGL 3.3 Reference Pages </b>
-<li> <a href="http://www.opengl.org/sdk/docs/man3/"> OpenGL 3.3 Reference
-     Pages </a> </li>
-
 <li> <b> OpenGL 3.2 </b>
 <li> <a href="specs/gl/glspec32.core.pdf"> (API Core Profile) </a> </li>
 <li> <a href="specs/gl/glspec32.compatibility.pdf"> (API Compatibility Profile) </a> </li>
@@ -209,7 +206,7 @@
      1.20 Specification </a> </li>
 
 <li> <b> OpenGL 2.1 Reference Pages </b>
-<li> <a href="http://www.opengl.org/sdk/docs/man/"> OpenGL 2.1 Reference
+<li> <a href="http://www.khronos.org/registry/OpenGL-Refpages/gl2.1/"> OpenGL 2.1 Reference
      Pages </a> </li>
 
 <li> <b> OpenGL 2.0 </b>
diff --git a/index_sc.php b/index_sc.php
index 7e4d935..f297da7 100644
--- a/index_sc.php
+++ b/index_sc.php
@@ -10,9 +10,10 @@
     documentation. </p>
 
 <p> The OpenGL SC Registry is part of the combined <a
-    href="http://www.opengl.org/registry/"> OpenGL Registry </a> for OpenGL,
-    OpenGL ES, and OpenGL SC, which includes the <a href="xml/README.md">XML
-    API registry</a> of reserved enumerants and functions. </p>
+    href="http://www.khronos.org/registry/OpenGL/"> Combined OpenGL Registry </a>
+    for OpenGL, OpenGL ES, and OpenGL SC, which includes the <a
+    href="xml/README.md">XML API registry</a> of reserved enumerants and
+    functions. </p>
 
 <h2> OpenGL SC Core API Specification, Headers, and Documentation </h2>
 
diff --git a/xml/gl.xml b/xml/gl.xml
index b51a17c..4f1e43b 100644
--- a/xml/gl.xml
+++ b/xml/gl.xml
@@ -2940,6 +2940,8 @@
         </group>
 
         <group name="ReadBufferMode">
+            <enum name="GL_NONE"/>
+            <enum name="GL_NONE_OES"/>
             <enum name="GL_AUX0"/>
             <enum name="GL_AUX1"/>
             <enum name="GL_AUX2"/>
@@ -3316,9 +3318,6 @@
         </group>
 
         <group name="FramebufferAttachment">
-            <enum name="GL_MAX_COLOR_ATTACHMENTS"/>
-            <enum name="GL_MAX_COLOR_ATTACHMENTS_EXT"/>
-            <enum name="GL_MAX_COLOR_ATTACHMENTS_NV"/>
             <enum name="GL_COLOR_ATTACHMENT0"/>
             <enum name="GL_COLOR_ATTACHMENT0_EXT"/>
             <enum name="GL_COLOR_ATTACHMENT0_NV"/>
@@ -3388,6 +3387,9 @@
             <enum name="GL_DEPTH_STENCIL_ATTACHMENT"/>
             <enum name="GL_DEPTH_ATTACHMENT_EXT"/>
             <enum name="GL_DEPTH_ATTACHMENT_OES"/>
+            <enum name="GL_STENCIL_ATTACHMENT"/>
+            <enum name="GL_STENCIL_ATTACHMENT_EXT"/>
+            <enum name="GL_STENCIL_ATTACHMENT_OES"/>
         </group>
 
         <group name="InvalidateFramebufferAttachment">
@@ -11502,6 +11504,10 @@
             <unused start="0x96A4" end="0x96AF" vendor="Qualcomm"/>
     </enums>
 
+    <enums namespace="GL" start="0x96B0" end="0x96BF" vendor="ANGLE" comment="github pull request">
+            <unused start="0x96B0" end="0x96BF" vendor="ANGLE"/>
+    </enums>
+
 <!-- Enums reservable for future use. To reserve a new range, allocate one
      or more multiples of 16 starting at the lowest available point in this
      block and note it in a new <enums> block immediately above.
@@ -11511,8 +11517,8 @@
      file) File requests in the Khronos Bugzilla, OpenGL project, Registry
      component. -->
 
-    <enums namespace="GL" start="0x96B0" end="99999" vendor="ARB" comment="RESERVED FOR FUTURE ALLOCATIONS BY KHRONOS">
-        <unused start="0x96B0" end="99999" comment="RESERVED"/>
+    <enums namespace="GL" start="0x96C0" end="99999" vendor="ARB" comment="RESERVED FOR FUTURE ALLOCATIONS BY KHRONOS">
+        <unused start="0x96C0" end="99999" comment="RESERVED"/>
     </enums>
 
 <!-- Historical large block allocations, all unused except (in older days) by IBM -->
