diff --git a/api/GL/glcorearb.h b/api/GL/glcorearb.h
index 44816da..5f22f81 100755
--- a/api/GL/glcorearb.h
+++ b/api/GL/glcorearb.h
@@ -306,7 +306,7 @@
 typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC) (GLenum target, GLint level, GLenum pname, GLfloat *params);
 typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC) (GLenum target, GLint level, GLenum pname, GLint *params);
 typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC) (GLenum cap);
-typedef void (APIENTRYP PFNGLDEPTHRANGEPROC) (GLdouble near, GLdouble far);
+typedef void (APIENTRYP PFNGLDEPTHRANGEPROC) (GLdouble n, GLdouble f);
 typedef void (APIENTRYP PFNGLVIEWPORTPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
 #ifdef GL_GLEXT_PROTOTYPES
 GLAPI void APIENTRY glCullFace (GLenum mode);
@@ -355,7 +355,7 @@
 GLAPI void APIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params);
 GLAPI void APIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params);
 GLAPI GLboolean APIENTRY glIsEnabled (GLenum cap);
-GLAPI void APIENTRY glDepthRange (GLdouble near, GLdouble far);
+GLAPI void APIENTRY glDepthRange (GLdouble n, GLdouble f);
 GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
 #endif
 #endif /* GL_VERSION_1_0 */
@@ -4650,6 +4650,11 @@
 #endif
 #endif /* GL_EXT_window_rectangles */
 
+#ifndef GL_INTEL_blackhole_render
+#define GL_INTEL_blackhole_render 1
+#define GL_BLACKHOLE_RENDER_INTEL         0x83FC
+#endif /* GL_INTEL_blackhole_render */
+
 #ifndef GL_INTEL_conservative_rasterization
 #define GL_INTEL_conservative_rasterization 1
 #define GL_CONSERVATIVE_RASTERIZATION_INTEL 0x83FE
diff --git a/api/GL/glext.h b/api/GL/glext.h
index 5c999aa..2510603 100644
--- a/api/GL/glext.h
+++ b/api/GL/glext.h
@@ -51,7 +51,7 @@
 #define GLAPI extern
 #endif
 
-#define GL_GLEXT_VERSION 20180221
+#define GL_GLEXT_VERSION 20180302
 
 /* Generated C header for:
  * API: gl
@@ -9115,6 +9115,11 @@
 #define GL_INTERLACE_READ_INGR            0x8568
 #endif /* GL_INGR_interlace_read */
 
+#ifndef GL_INTEL_blackhole_render
+#define GL_INTEL_blackhole_render 1
+#define GL_BLACKHOLE_RENDER_INTEL         0x83FC
+#endif /* GL_INTEL_blackhole_render */
+
 #ifndef GL_INTEL_conservative_rasterization
 #define GL_INTEL_conservative_rasterization 1
 #define GL_CONSERVATIVE_RASTERIZATION_INTEL 0x83FE
diff --git a/api/GLES/gl.h b/api/GLES/gl.h
index b573b5c..0d20c21 100644
--- a/api/GLES/gl.h
+++ b/api/GLES/gl.h
@@ -36,7 +36,7 @@
 
 #include <GLES/glplatform.h>
 
-/* Generated on date 20180221 */
+/* Generated on date 20180302 */
 
 /* Generated C header for:
  * API: gles1
diff --git a/api/GLES/glext.h b/api/GLES/glext.h
index 63d088d..00ce389 100644
--- a/api/GLES/glext.h
+++ b/api/GLES/glext.h
@@ -38,7 +38,7 @@
 #define GL_APIENTRYP GL_APIENTRY*
 #endif
 
-/* Generated on date 20180221 */
+/* Generated on date 20180302 */
 
 /* Generated C header for:
  * API: gles1
diff --git a/api/GLES2/gl2.h b/api/GLES2/gl2.h
index eae547d..dc5744f 100644
--- a/api/GLES2/gl2.h
+++ b/api/GLES2/gl2.h
@@ -44,7 +44,7 @@
 #define GL_GLES_PROTOTYPES 1
 #endif
 
-/* Generated on date 20180221 */
+/* Generated on date 20180302 */
 
 /* Generated C header for:
  * API: gles2
diff --git a/api/GLES2/gl2ext.h b/api/GLES2/gl2ext.h
index e6e948b..5cecd47 100644
--- a/api/GLES2/gl2ext.h
+++ b/api/GLES2/gl2ext.h
@@ -38,7 +38,7 @@
 #define GL_APIENTRYP GL_APIENTRY*
 #endif
 
-/* Generated on date 20180221 */
+/* Generated on date 20180302 */
 
 /* Generated C header for:
  * API: gles2
@@ -2321,6 +2321,11 @@
 #define GL_CUBIC_MIPMAP_LINEAR_IMG        0x913B
 #endif /* GL_IMG_texture_filter_cubic */
 
+#ifndef GL_INTEL_blackhole_render
+#define GL_INTEL_blackhole_render 1
+#define GL_BLACKHOLE_RENDER_INTEL         0x83FC
+#endif /* GL_INTEL_blackhole_render */
+
 #ifndef GL_INTEL_conservative_rasterization
 #define GL_INTEL_conservative_rasterization 1
 #define GL_CONSERVATIVE_RASTERIZATION_INTEL 0x83FE
diff --git a/api/GLES3/gl3.h b/api/GLES3/gl3.h
index 80d8581..747a74e 100644
--- a/api/GLES3/gl3.h
+++ b/api/GLES3/gl3.h
@@ -44,7 +44,7 @@
 #define GL_GLES_PROTOTYPES 1
 #endif
 
-/* Generated on date 20180221 */
+/* Generated on date 20180302 */
 
 /* Generated C header for:
  * API: gles2
diff --git a/extensions/AMD/AMD_gpu_shader_half_float_fetch.txt b/extensions/AMD/AMD_gpu_shader_half_float_fetch.txt
index 8a4aca0..03ac34e 100644
--- a/extensions/AMD/AMD_gpu_shader_half_float_fetch.txt
+++ b/extensions/AMD/AMD_gpu_shader_half_float_fetch.txt
@@ -1751,58 +1751,94 @@
     +--------------------------------------------------------------+------------------------------+
     | Syntax                                                       | Description                  |
     +--------------------------------------------------------------+------------------------------+
-    | f16vec4 textureGather(f16sampler2D sampler, f16vec2 P        | Returns the value            |
-    |                       [, int comp [, float16_t bias]])       |                              |
-    | f16vec4 textureGather(f16sampler2DArray sampler, f16vec3 P   | gvec4(                       |
+    | f16vec4 textureGather(f16sampler2D sampler, vec2 P           | Returns the value            |
+    |                       [, int comp [, float bias]])           |                              |
+    | f16vec4 textureGather(f16sampler2D sampler, f16vec2 P        | gvec4(                       |
     |                       [, int comp [, float16_t bias]])       |   Sample_i0_j1(              |
-    | f16vec4 textureGather(f16samplerCube sampler, f16vec3 P      |     P, base, bias).comp,     |
-    |                       [, int comp [, float16_t bias]])       |   Sample_i1_j1(              |
-    | f16vec4 textureGather(f16samplerCubeArray sampler, f16vec4 P |     P, base, bias).comp,     |
+    | f16vec4 textureGather(f16sampler2DArray sampler, vec3 P      |     P, base, bias).comp,     |
+    |                       [, int comp [, float bias]])           |   Sample_i1_j1(              |
+    | f16vec4 textureGather(f16sampler2DArray sampler, f16vec3 P   |     P, base, bias).comp,     |
     |                       [, int comp [, float16_t bias]])       |   Sample_i1_j0(              |
-    |                                                              |     P, base, bias).comp,     |
-    |                                                              |   Sample_i0_j0(              |
-    |                                                              |     P, base, bias).comp)     |
-    |                                                              | ...                          |
+    | f16vec4 textureGather(f16samplerCube sampler, vec3 P         |     P, base, bias).comp,     |
+    |                       [, int comp [, float bias]])           |   Sample_i0_j0(              |
+    | f16vec4 textureGather(f16samplerCube sampler, f16vec3 P      |     P, base, bias).comp,     |
+    |                       [, int comp [, float16_t bias]])       | ...                          |
+    | f16vec4 textureGather(f16samplerCubeArray sampler, vec4 P    |                              |
+    |                       [, int comp [, float bias]])           |                              |
+    | f16vec4 textureGather(f16samplerCubeArray sampler, f16vec4 P |                              |
+    |                       [, int comp [, float16_t bias]])       |                              |
     +--------------------------------------------------------------+------------------------------+
-    | f16vec4 textureGatherOffset(f16sampler2D sampler, f16vec2 P, | Perform a texture gather     |
+    | f16vec4 textureGatherOffset(f16sampler2D sampler, vec2 P,    | Perform a texture gather     |
     |                             ivec2 offset [, int comp         | operation as in              |
-    |                             [, float16_t bias]])             | textureGather() by <offset>  |
-    | f16vec4 textureGatherOffset(f16sampler2DArray sampler,       | as described in              |
-    |                             f16vec3 P, ivec2 offset          | textureOffset() except that  |
-    |                             [, int comp [, float16_t bias]]) | the <offset> can be variable |
-    |                                                              | (non constant) and ...       |
+    |                             [, float bias]])                 | textureGather() by <offset>  |
+    | f16vec4 textureGatherOffset(f16sampler2D sampler, f16vec2 P, | as described in              |
+    |                             ivec2 offset [, int comp         | textureOffset() except that  |
+    |                             [, float16_t bias]])             | the <offset> can be variable |
+    | f16vec4 textureGatherOffset(f16sampler2DArray sampler,       | (non constant) and ...       |
+    |                             vec3 P, ivec2 offset             |                              |
+    |                             [, int comp [, float bias]])     |                              |
+    | f16vec4 textureGatherOffset(f16sampler2DArray sampler,       |                              |
+    |                             f16vec3 P, ivec2 offset          |                              |
+    |                             [, int comp [, float16_t bias]]) |                              |
     +--------------------------------------------------------------+------------------------------+
-    | f16vec4 textureGatherOffsets(f16sampler2D sampler, f16vec2 P,| Operate identically to       |
+    | f16vec4 textureGatherOffsets(f16sampler2D sampler, vec2 P,   | Operate identically to       |
     |                              ivec2 offsets[4] [, int comp    | textureGatherOffset() except |
-    |                              [, float16_t bias]])            | that <offsets> is used to    |
-    | f16vec4 textureGatherOffsets(f16sampler2DArray sampler,      | determine the location of the|
-    |                              f16vec3 P, ivec2 offsets[4]     | four texels to sample. ...   |
+    |                              [, float bias]])                | that <offsets> is used to    |
+    | f16vec4 textureGatherOffsets(f16sampler2D sampler, f16vec2 P,| determine the location of the|
+    |                              ivec2 offsets[4] [, int comp    | four texels to sample. ...   |
+    |                              [, float16_t bias]])            |                              |
+    | f16vec4 textureGatherOffsets(f16sampler2DArray sampler,      |                              |
+    |                              vec3 P, ivec2 offsets[4]        |                              |
+    |                              [, int comp [, float bias]])    |                              |
+    | f16vec4 textureGatherOffsets(f16sampler2DArray sampler,      |                              |
+    |                              f16vec3 P, ivec2 offsets[4]     |                              |
     |                              [, int comp [, float16_t bias]])|                              |
     +--------------------------------------------------------------+------------------------------+
-    | f16vec4 textureGatherLodAMD(f16sampler2D sampler, f16vec2 P, | Perform a texture gather     |
-    |                             float16_t lod [, int comp])      | operation as in              |
-    | f16vec4 textureGatherLodAMD(f16sampler2DArray sampler,       | textureGather() with explicit|
-    |                             f16vec3 P, float16_t lod         | LOD, but the four-texel      |
-    |                             [, int comp])                    | sampling is modified as      |
-    | f16vec4 textureGatherLodAMD(f16samplerCube sampler,          | follow:                      |
+    | f16vec4 textureGatherLodAMD(f16sampler2D sampler, vec2 P,    | Perform a texture gather     |
+    |                             float lod [, int comp])          | operation as in              |
+    | f16vec4 textureGatherLodAMD(f16sampler2D sampler, f16vec2 P, | textureGather() with explicit|
+    |                             float16_t lod [, int comp])      | LOD, but the four-texel      |
+    | f16vec4 textureGatherLodAMD(f16sampler2DArray sampler,       | sampling is modified as      |
+    |                             vec3 P, float lod [, int comp])  | follow:                      |
+    | f16vec4 textureGatherLodAMD(f16sampler2DArray sampler,       |                              |
+    |                             f16vec3 P, float16_t lod         | gvec4(                       |
+    |                             [, int comp])                    |   Sample_i0_j1(P, lod).comp, |
+    | f16vec4 textureGatherLodAMD(f16samplerCube sampler,          |   Sample_i1_j1(P, lod).comp, |
+    |                             vec3 P, float lod [, int comp])  |   Sample_i1_j0(P, lod).comp, |
+    | f16vec4 textureGatherLodAMD(f16samplerCube sampler,          |   Sample_i0_j0(P, lod).comp) |
     |                             f16vec3 P, float16_t lod         |                              |
-    |                             [, int comp])                    | gvec4(                       |
-    | f16vec4 textureGatherLodAMD(f16samplerCubeArray sampler,     |   Sample_i0_j1(P, lod).comp, |
-    |                             f16vec4 P, float16_t lod         |   Sample_i1_j1(P, lod).comp, |
-    |                             [, int comp])                    |   Sample_i1_j0(P, lod).comp, |
-    |                                                              |   Sample_i0_j0(P, lod).comp) |
+    |                             [, int comp])                    |                              |
+    | f16vec4 textureGatherLodAMD(f16samplerCubeArray sampler,     |                              |
+    |                             vec4 P, float lod [, int comp])  |                              |
+    | f16vec4 textureGatherLodAMD(f16samplerCubeArray sampler,     |                              |
+    |                             f16vec4 P, float16_t lod         |                              |
+    |                             [, int comp])                    |                              |
     +--------------------------------------------------------------+------------------------------+
     | f16vec4 textureGatherLodOffsetAMD(f16sampler2D sampler,      | Perform a texture gather     |
-    |                                   f16vec2 P, float16_t lod,  | operation as in              |
+    |                                   vec2 P, float lod,         | operation as in              |
     |                                   ivec2 offset [, int comp]) | textureGatherOffset() but    |
-    | f16vec4 textureGatherLodOffsetAMD(f16sampler2DArray sampler, | with explicit LOD.           |
+    | f16vec4 textureGatherLodOffsetAMD(f16sampler2D sampler,      | with explicit LOD.           |
+    |                                   f16vec2 P, float16_t lod,  |                              |
+    |                                   ivec2 offset [, int comp]) |                              |
+    | f16vec4 textureGatherLodOffsetAMD(f16sampler2DArray sampler, |                              |
+    |                                   vec3 P, float lod,         |                              |
+    |                                   ivec2 offset [, int comp]) |                              |
+    | f16vec4 textureGatherLodOffsetAMD(f16sampler2DArray sampler, |                              |
     |                                   f16vec3 P, float16_t lod,  |                              |
     |                                   ivec2 offset [, int comp]) |                              |
     +--------------------------------------------------------------+------------------------------+
     | f16vec4 textureGatherLodOffsetsAMD(f16sampler2D sampler,     | Perform a texture gather     |
-    |                                    f16vec2 P, float16_t lod, | operation as in              |
+    |                                    vec2 P, float lod,        | operation as in              |
     |                                    ivec2 offsets[4]          | textureGatherOffsets() but   |
     |                                    [, int comp])             | with explicit LOD.           |
+    | f16vec4 textureGatherLodOffsetsAMD(f16sampler2D sampler,     |                              |
+    |                                    f16vec2 P, float16_t lod, |                              |
+    |                                    ivec2 offsets[4]          |                              |
+    |                                    [, int comp])             |                              |
+    | f16vec4 textureGatherLodOffsetsAMD(f16sampler2DArray sampler,|                              |
+    |                                    vec3 P, float lod,        |                              |
+    |                                    ivec2 offsets[4]          |                              |
+    |                                    [, int comp])             |                              |
     | f16vec4 textureGatherLodOffsetsAMD(f16sampler2DArray sampler,|                              |
     |                                    f16vec3 P, float16_t lod, |                              |
     |                                    ivec2 offsets[4]          |                              |
@@ -1816,54 +1852,144 @@
     +--------------------------------------------------------------+------------------------------+
     | Syntax                                                       | Description                  |
     +--------------------------------------------------------------+------------------------------+
-    | int sparseTextureGatherARB(f16sampler2D sampler, f16vec2 P,  | Do a texture gather operation|
+    | int sparseTextureGatherARB(f16sampler2D sampler, vec2 P,     | Do a texture gather operation|
     |                            out f16vec4 texel [, int comp     | as in textureGather(), but   |
-    |                            [, float16_t bias]])              | return texture access        |
-    | int sparseTextureGatherARB(f16sampler2DArray sampler,        | residency information from   |
-    |                            f16vec3 P, out f16vec4 texel      | the function and the filtered|
-    |                            [, int comp [, float16_t bias]])  | lookup result in the out     |
-    | int sparseTextureGatherARB(f16samplerCube sampler, f16vec3 P,| parameter <texel>.           |
+    |                            [, float bias]])                  | return texture access        |
+    | int sparseTextureGatherARB(f16sampler2D sampler, f16vec2 P,  | residency information from   |
+    |                            out f16vec4 texel [, int comp     | the function and the filtered|
+    |                            [, float16_t bias]])              | lookup result in the out     |
+    | int sparseTextureGatherARB(f16sampler2DArray sampler,        | parameter <texel>.           |
+    |                            vec3 P, out f16vec4 texel         |                              |
+    |                            [, int comp [, float bias]])      |                              |
+    | int sparseTextureGatherARB(f16sampler2DArray sampler,        |                              |
+    |                            f16vec3 P, out f16vec4 texel      |                              |
+    |                            [, int comp [, float16_t bias]])  |                              |
+    | int sparseTextureGatherARB(f16samplerCube sampler, vec3 P,   |                              |
+    |                            out f16vec4 texel [, int comp     |                              |
+    |                            [, float bias]])                  |                              |
+    | int sparseTextureGatherARB(f16samplerCube sampler, f16vec3 P,|                              |
     |                            out f16vec4 texel [, int comp     |                              |
     |                            [, float16_t bias]])              |                              |
     | int sparseTextureGatherARB(f16samplerCubeArray sampler,      |                              |
-    |                             16vec4 P, out f16vec4 texel      |                              |
+    |                            vec4 P, out f16vec4 texel         |                              |
+    |                            [, int comp [, float bias]])      |                              |
+    | int sparseTextureGatherARB(f16samplerCubeArray sampler,      |                              |
+    |                            f16vec4 P, out f16vec4 texel      |                              |
     |                            [, int comp [, float16_t bias]])  |                              |
     +--------------------------------------------------------------+------------------------------+
     | int sparseTextureGatherOffsetARB(f16sampler2D sampler,       | Do a texture gather operation|
-    |                                  f16vec2 P, ivec2 offset,    | as in textureGatherOffset(), |
+    |                                  vec2 P, ivec2 offset,       | as in textureGatherOffset(), |
     |                                  out f16vec4 texel           | but return texture access    |
-    |                                  [, int comp                 | residency information from   |
-    |                                  [, float16_t bias]])        | the function and the filtered|
-    | int sparseTextureGatherOffsetARB(f16sampler2DArray sampler,  | lookup result in the out     |
-    |                                  f16vec3 P, ivec2 offset,    | parameter <texel>.           |
+    |                                  [, int comp [, float bias]])| residency information from   |
+    | int sparseTextureGatherOffsetARB(f16sampler2D sampler,       | the function and the filtered|
+    |                                  f16vec2 P, ivec2 offset,    | lookup result in the out     |
+    |                                  out f16vec4 texel           | parameter <texel>.           |
+    |                                  [, int comp                 |                              |
+    |                                  [, float16_t bias]])        |                              |
+    | int sparseTextureGatherOffsetARB(f16sampler2DArray sampler,  |                              |
+    |                                  vec3 P, ivec2 offset,       |                              |
+    |                                  out f16vec4 texel           |                              |
+    |                                  [, int comp [, float bias]])|                              |
+    | int sparseTextureGatherOffsetARB(f16sampler2DArray sampler,  |                              |
+    |                                  f16vec3 P, ivec2 offset,    |                              |
     |                                  out f16vec4 texel           |                              |
     |                                  [, int comp                 |                              |
     |                                  [, float16_t bias]])        |                              |
     +--------------------------------------------------------------+------------------------------+
+    | int sparseTextureGatherOffsetsARB(f16sampler2D sampler,      | Do a texture gather operation|
+    |                                   vec2 P, ivec2 offsets[4],  | as in textureGatherOffsets(),|
+    |                                   out f16vec4 texel          | but return texture access    |
+    |                                   [, int comp                | residency information from   |
+    |                                   [, float bias]])           | the function and the filtered|
+    | int sparseTextureGatherOffsetsARB(f16sampler2D sampler,      | lookup result in the out     |
+    |                                   f16vec2 P,                 | parameter <texel>.           |
+    |                                   ivec2 offsets[4],          |                              |
+    |                                   out f16vec4 texel          |                              |
+    |                                   [, int comp                |                              |
+    |                                   [, float16_t bias]])       |                              |
+    | int sparseTextureGatherOffsetsARB(f16sampler2DArray sampler, |                              |
+    |                                   vec3 P, ivec2 offsets[4],  |                              |
+    |                                   out f16vec4 texel          |                              |
+    |                                   [, int comp                |                              |
+    |                                   [, float bias]])           |                              |
+    | int sparseTextureGatherOffsetsARB(f16sampler2DArray sampler, |                              |
+    |                                   f16vec3 P,                 |                              |
+    |                                   ivec2 offsets[4],          |                              |
+    |                                   out f16vec4 texel          |                              |
+    |                                   [, int comp                |                              |
+    |                                   [, float16_t bias]])       |                              |
+    +--------------------------------------------------------------+------------------------------+
     | int sparseTextureGatherLodAMD(f16sampler2D sampler,          | Do a texture gather operation|
-    |                               f16vec2 P, float16_t lod,      | as in textureGather() with,  |
+    |                               vec2 P, float lod,             | as in textureGather() with,  |
     |                               out f16vec4 texel [, int comp])| explicit LOD, but return     |
-    | int sparseTextureGatherLodAMD(f16sampler2DArray sampler,     | texture access residency     |
-    |                               f16vec3 P, float16_t lod,      | information from the function|
+    | int sparseTextureGatherLodAMD(f16sampler2D sampler,          | texture access residency     |
+    |                               f16vec2 P, float16_t lod,      | information from the function|
     |                               out f16vec4 texel [, int comp])| and the filtered lookup      |
-    | int sparseTextureGatherLodAMD(f16samplerCube sampler,        | result in the out parameter  |
-    |                               f16vec3 P, float16_t lod,      | <texel>.                     |
+    | int sparseTextureGatherLodAMD(f16sampler2DArray sampler,     | result in the out parameter  |
+    |                               vec3 P, float lod,             | <texel>.                     |
+    |                               out f16vec4 texel [, int comp])|                              |
+    | int sparseTextureGatherLodAMD(f16sampler2DArray sampler,     |                              |
+    |                               f16vec3 P, float16_t lod,      |                              |
+    |                               out f16vec4 texel [, int comp])|                              |
+    | int sparseTextureGatherLodAMD(f16samplerCube sampler,        |                              |
+    |                               vec3 P, float lod,             |                              |
+    |                               out f16vec4 texel [, int comp])|                              |
+    | int sparseTextureGatherLodAMD(f16samplerCube sampler,        |                              |
+    |                               f16vec3 P, float16_t lod,      |                              |
+    |                               out f16vec4 texel [, int comp])|                              |
+    | int sparseTextureGatherLodAMD(f16samplerCubeArray sampler,   |                              |
+    |                               vec4 P, float lod,             |                              |
     |                               out f16vec4 texel [, int comp])|                              |
     | int sparseTextureGatherLodAMD(f16samplerCubeArray sampler,   |                              |
     |                               f16vec4 P, float16_t lod,      |                              |
     |                               out f16vec4 texel [, int comp])|                              |
     +--------------------------------------------------------------+------------------------------+
     | int sparseTextureGatherLodOffsetAMD(f16sampler2D sampler,    | Do a texture gather operation|
-    |                                     f16vec2 P, float16_t lod,| as in textureGatherOffset()  |
+    |                                     vec2 P, float lod,       | as in textureGatherOffset()  |
     |                                     ivec2 offset,            | with explicit LOD, but return|
     |                                     out f16vec4 texel        | texture access residency     |
     |                                     [, int comp])            | information from the function|
-    | int sparseTextureGatherLodOffsetAMD(f16sampler2DArray        | and the filtered lookup      |
-    |                                     sampler, f16vec3 P,      | result in the out parameter  |
-    |                                     float16_t lod,           | <texel>.                     |
+    | int sparseTextureGatherLodOffsetAMD(f16sampler2D sampler,    | and the filtered lookup      |
+    |                                     f16vec2 P, float16_t lod,| result in the out parameter  |
+    |                                     ivec2 offset,            | <texel>.                     |
+    |                                     out f16vec4 texel        |                              |
+    |                                     [, int comp])            |                              |
+    | int sparseTextureGatherLodOffsetAMD(f16sampler2DArray        |                              |
+    |                                     sampler, vec3 P,         |                              |
+    |                                     float lod,               |                              |
     |                                     ivec2 offset,            |                              |
     |                                     out f16vec4 texel        |                              |
     |                                     [, int comp])            |                              |
+    | int sparseTextureGatherLodOffsetAMD(f16sampler2DArray        |                              |
+    |                                     sampler, f16vec3 P,      |                              |
+    |                                     float16_t lod,           |                              |
+    |                                     ivec2 offset,            |                              |
+    |                                     out f16vec4 texel        |                              |
+    |                                     [, int comp])            |                              |
+    +--------------------------------------------------------------+------------------------------+
+    | int sparseTextureGatherLodOffsetsAMD(f16sampler2D sampler,   | Do a texture gather operation|
+    |                                      vec2 P, float lod,      | as in textureGatherOffsets() |
+    |                                      ivec2 offsets[4],       | with explicit LOD, but return|
+    |                                      out f16vec4 texel       | texture access residency     |
+    |                                      [, int comp])           | information from the function|
+    | int sparseTextureGatherLodOffsetsAMD(f16sampler2D sampler,   | and the filtered lookup      |
+    |                                      f16vec2 P,              | result in the out parameter  |
+    |                                      float16_t lod,          | <texel>.                     |
+    |                                      ivec2 offsets[4],       |                              |
+    |                                      out f16vec4 texel       |                              |
+    |                                      [, int comp])           |                              |
+    | int sparseTextureGatherLodOffsetsAMD(f16sampler2DArray       |                              |
+    |                                      sampler, vec3 P,        |                              |
+    |                                      float lod,              |                              |
+    |                                      ivec2 offsets[4],       |                              |
+    |                                      out f16vec4 texel       |                              |
+    |                                      [, int comp])           |                              |
+    | int sparseTextureGatherLodOffsetsAMD(f16sampler2DArray       |                              |
+    |                                      sampler, f16vec3 P,     |                              |
+    |                                      float16_t lod,          |                              |
+    |                                      ivec2 offsets[4],       |                              |
+    |                                      out f16vec4 texel       |                              |
+    |                                      [, int comp])           |                              |
     +--------------------------------------------------------------+------------------------------+
 
 Errors
@@ -1908,9 +2034,12 @@
 
     Rev.  Date      Author    Changes
     ----  --------  --------  ---------------------------------------------------------------------
-     5    9/20/17   dwitczak  Fix incorrect definitions of some of the textureClampARB(), textureGradClampARB(),
-                              textureLod() and textureProjLodOffset() function prototypes.
-                              Remove duplicate function prototype definitions.
+     6    3/9/18    rexu      Add some missing function prototypes when this extension interacts
+                              with AMD_texture_gather_bias_lod.
+
+     5    9/20/17   dwitczak  Fix incorrect definitions of some of the textureClampARB(),
+                              textureGradClampARB(), textureLod() and textureProjLodOffset()
+                              function prototypes. Remove duplicate function prototype definitions.
 
      4    11/24/16  rexu      Clarify that when <compare> is present in shadow forms of
                               textureProj*(), the resulting <compare>, by divding its initial value
diff --git a/extensions/INTEL/INTEL_blackhole_render.txt b/extensions/INTEL/INTEL_blackhole_render.txt
new file mode 100644
index 0000000..550b07b
--- /dev/null
+++ b/extensions/INTEL/INTEL_blackhole_render.txt
@@ -0,0 +1,124 @@
+Name
+
+    INTEL_blackhole_render
+
+Name Strings
+
+    GL_INTEL_blackhole_render
+
+Contact
+
+    Lionel Landwerlin, Intel  (lionel.g.landwerlin 'at' intel.com)
+
+Contributors
+
+    Ben Widawsky (benjamin.widawsky 'at' intel.com)
+
+Status
+
+    Draft.
+
+Version
+
+    Last Modified Date:        03/02/2018
+    INTEL Revision:            1
+
+Number
+
+    OpenGL Extension #521
+    OpenGL ES Extension #300
+
+Dependencies
+
+    OpenGL dependencies:
+
+        OpenGL 3.0 is required.
+
+        The extension is written against the OpenGL 4.6 Specification, Core
+        Profile, July 30, 2017.
+
+    OpenGL ES dependencies:
+
+        This extension is written against the OpenGL ES 3.2 Specification,
+        November 3, 2016.
+
+Overview
+
+    The purpose of this extension is to allow an application to disable all
+    rendering operations emitted to the GPU through the OpenGL rendering
+    commands (Draw*, DispatchCompute*, BlitFramebuffer, etc...). Changes to the
+    OpenGL pipeline are not affected.
+
+    New preprocessor #defines are added to the OpenGL Shading Language:
+
+      #define GL_INTEL_blackhole_render 1
+
+New Procedures and Functions
+
+    None.
+
+New Tokens
+
+    Accepted by the <target> parameter of Enable, Disable, IsEnabled:
+
+        BLACKHOLE_RENDER_INTEL  0x83FC
+
+Additions to the OpenGL 4.6 (Core Profile) Specification
+
+    Modify section 2.4 Rendering Commands (add new text at the end of the
+    section)
+
+    The effect of the above commands can be disabled by enabling
+    BLACKHOLE_RENDER_INTEL.
+
+Additions to Chapter 14.2.2, Shader Inputs of the OpenGL ES 3.2 Specification
+
+    Modify section 2.4 Rendering Commands (add new text at the end of the
+    section)
+
+    The effect of the above commands can be disabled by enabling
+    BLACKHOLE_RENDER_INTEL.
+
+Additions to the AGL/GLX/WGL Specifications
+
+    None.
+
+GLX Protocol
+
+    None.
+
+Errors
+
+    None.
+
+New State in OpenGL 4.6 Core Profile
+
+    (add new row to the Table 23.74, Miscellaneous)
+
+                                     Initial
+    Get Value      Type  Get Command  Value  Description                 Sec.
+    -------------  ----  ----------- ------- -------------------------   ------
+    BLACKHOLE_
+    RENDERING_     B     IsEnabled()  FALSE  Disable rendering           2.4
+    INTEL
+
+New State in OpenGL ES 3.2
+
+    (add new row to the Table 21.57, Miscellaneous)
+
+                                     Initial
+    Get Value      Type  Get Command  Value  Description                 Sec.
+    -------------  ----  ----------- ------- -------------------------   ------
+    BLACKHOLE_
+    RENDERING_     B     IsEnabled()  FALSE  Disable rendering           2.4
+    INTEL
+
+Issues
+
+    None.
+
+Revision History
+
+    Rev.     Date       Author       Changes
+    ----  ----------  ----------  -----------------------------------------
+      1    3/2/2018   llandwerlin Initial revision.
diff --git a/extensions/QCOM/QCOM_texture_foveated.txt b/extensions/QCOM/QCOM_texture_foveated.txt
index f021916..007189b 100644
--- a/extensions/QCOM/QCOM_texture_foveated.txt
+++ b/extensions/QCOM/QCOM_texture_foveated.txt
@@ -20,7 +20,7 @@
 
 Status
 
-    Draft
+    Complete
 
 Version
 
@@ -357,8 +357,6 @@
     same framebuffer. In this case the depth and/or stencil attachments should
     be discarded or invalidated after rendering, as the upscaled depth contents
     are unlikely to be useful and may cause undesired rendering artifacts when used.
-    An implementation may choose to discard the contents of the depth/stencil
-    buffers instead of resolving and upscaling them.
 
     6. Does foveation have any effect on BlitFramebuffer.
 
@@ -471,3 +469,5 @@
      3    09/25/17   tateh     Add max scale factor texture parameter.
      4    10/3/17    tateh     Add Table 21.10 modifications and issue #9
      5    10/6/17    tateh     Changed max scale factor to min pixel density
+     6    01/8/17    tateh     Removed depth/stencil discard and invalidate
+                               language.
diff --git a/extensions/esext.php b/extensions/esext.php
index b79083b..d1ee6f3 100644
--- a/extensions/esext.php
+++ b/extensions/esext.php
@@ -623,4 +623,6 @@
 </li>
 <li value=299><a href="extensions/EXT/EXT_texture_format_sRGB_override.txt">GL_EXT_texture_format_sRGB_override</a>
 </li>
+<li value=300><a href="extensions/INTEL/INTEL_blackhole_render.txt">GL_INTEL_blackhole_render</a>
+</li>
 </ol>
diff --git a/extensions/glext.php b/extensions/glext.php
index 725adcb..47c2e8a 100644
--- a/extensions/glext.php
+++ b/extensions/glext.php
@@ -979,4 +979,6 @@
 
     <br> <a href="extensions/EXT/EXT_shader_framebuffer_fetch.txt">GL_EXT_shader_framebuffer_fetch_non_coherent</a>
 </li>
+<li value=521><a href="extensions/INTEL/INTEL_blackhole_render.txt">GL_INTEL_blackhole_render</a>
+</li>
 </ol>
diff --git a/extensions/registry.py b/extensions/registry.py
index 11b001e..b8c0630 100644
--- a/extensions/registry.py
+++ b/extensions/registry.py
@@ -2798,6 +2798,13 @@
         'supporters' : { 'INTEL' },
         'url' : 'extensions/INTEL/INTEL_map_texture.txt',
     },
+    'GL_INTEL_blackhole_render' : {
+        'number' : 521,
+        'esnumber' : 300,
+        'flags' : { 'public' },
+        'supporters' : { 'INTEL' },
+        'url' : 'extensions/INTEL/INTEL_blackhole_render.txt',
+    },
     'GL_INTEL_parallel_arrays' : {
         'number' : 136,
         'flags' : { 'public' },
diff --git a/xml/gl.xml b/xml/gl.xml
index d3b09da..6aa6482 100644
--- a/xml/gl.xml
+++ b/xml/gl.xml
@@ -5779,7 +5779,8 @@
         <enum value="0x83F9" name="GL_PERFQUERY_DONOT_FLUSH_INTEL"/>
         <enum value="0x83FA" name="GL_PERFQUERY_FLUSH_INTEL"/>
         <enum value="0x83FB" name="GL_PERFQUERY_WAIT_INTEL"/>
-            <unused start="0x83FC" end="0x83FD" vendor="INTEL"/>
+        <enum value="0x83FC" name="GL_BLACKHOLE_RENDER_INTEL"/>
+            <unused start="0x83FD" vendor="INTEL"/>
         <enum value="0x83FE" name="GL_CONSERVATIVE_RASTERIZATION_INTEL"/>
         <enum value="0x83FF" name="GL_TEXTURE_MEMORY_LAYOUT_INTEL"/>
     </enums>
@@ -13785,8 +13786,8 @@
         </command>
         <command>
             <proto>void <name>glDepthRange</name></proto>
-            <param><ptype>GLdouble</ptype> <name>near</name></param>
-            <param><ptype>GLdouble</ptype> <name>far</name></param>
+            <param><ptype>GLdouble</ptype> <name>n</name></param>
+            <param><ptype>GLdouble</ptype> <name>f</name></param>
             <glx type="render" opcode="174"/>
         </command>
         <command>
@@ -45448,6 +45449,11 @@
                 <command name="glMapTexture2DINTEL"/>
             </require>
         </extension>
+        <extension name="GL_INTEL_blackhole_render" supported="gl|glcore|gles2">
+            <require>
+                <enum name="GL_BLACKHOLE_RENDER_INTEL"/>
+            </require>
+        </extension>
         <extension name="GL_INTEL_parallel_arrays" supported="gl">
             <require>
                 <enum name="GL_PARALLEL_ARRAYS_INTEL"/>
diff --git a/xml/readme.tex b/xml/readme.tex
index 90d6ee2..60e5002 100644
--- a/xml/readme.tex
+++ b/xml/readme.tex
@@ -471,14 +471,14 @@
 tag are optional and may be in any order:
 
 \begin{itemize}
-\item \tag{alias} has no attributes and contains a string which is the
+\item \tag{alias} has one attribute, \attr{name}, containing a string which is the
       name of another command this command is an alias of, used when
       promoting a function from extension to ARB or ARB to API status. A
       command alias describes the case where there are two function
       names which resolve to the {\bf same} client library code, so (for
       example) the case where a command is promoted but is also given
       different GLX protocol would {\bf not} be an alias in this sense.
-\item \tag{vecequiv} has no attributes and contains a string which is
+\item \tag{vecequiv} has one attribute, \attr{name}, containing a string which is
       the name of another command which is the {\em vector equivalent}
       of this command. For example, the vector equivalent of
       \code{glVertex3f} is \code{glVertex3fv}.