From: Mark Young <marky@lunarg.com>
Date: Fri, 2 Sep 2016 17:41:28 +0000 (-0600)
Subject: loader: Rename DevExt to dev_ext
X-Git-Tag: upstream/1.1.92~2599
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=bf2f64665e61e10875780d8e87c62612f96ccda1;p=platform%2Fupstream%2FVulkan-Tools.git

loader: Rename DevExt to dev_ext

Make a quick change to conform a structure element to the coding
standard.

Change-Id: Icbf168b1ab451dcc4847a0c2c17d0cb40c0197b8
---

diff --git a/loader/dev_ext_trampoline.c b/loader/dev_ext_trampoline.c
index b63f828..e417e7e 100644
--- a/loader/dev_ext_trampoline.c
+++ b/loader/dev_ext_trampoline.c
@@ -24,2008 +24,2008 @@
 #pragma GCC optimize(3) // force gcc to use tail-calls
 #endif
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt0(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext0(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[0](device);
+    disp->ext_dispatch.dev_ext[0](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt1(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext1(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[1](device);
+    disp->ext_dispatch.dev_ext[1](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt2(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext2(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[2](device);
+    disp->ext_dispatch.dev_ext[2](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt3(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext3(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[3](device);
+    disp->ext_dispatch.dev_ext[3](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt4(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext4(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[4](device);
+    disp->ext_dispatch.dev_ext[4](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt5(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext5(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[5](device);
+    disp->ext_dispatch.dev_ext[5](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt6(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext6(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[6](device);
+    disp->ext_dispatch.dev_ext[6](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt7(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext7(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[7](device);
+    disp->ext_dispatch.dev_ext[7](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt8(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext8(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[8](device);
+    disp->ext_dispatch.dev_ext[8](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt9(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext9(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[9](device);
+    disp->ext_dispatch.dev_ext[9](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt10(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext10(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[10](device);
+    disp->ext_dispatch.dev_ext[10](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt11(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext11(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[11](device);
+    disp->ext_dispatch.dev_ext[11](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt12(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext12(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[12](device);
+    disp->ext_dispatch.dev_ext[12](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt13(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext13(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[13](device);
+    disp->ext_dispatch.dev_ext[13](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt14(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext14(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[14](device);
+    disp->ext_dispatch.dev_ext[14](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt15(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext15(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[15](device);
+    disp->ext_dispatch.dev_ext[15](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt16(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext16(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[16](device);
+    disp->ext_dispatch.dev_ext[16](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt17(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext17(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[17](device);
+    disp->ext_dispatch.dev_ext[17](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt18(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext18(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[18](device);
+    disp->ext_dispatch.dev_ext[18](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt19(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext19(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[19](device);
+    disp->ext_dispatch.dev_ext[19](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt20(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext20(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[20](device);
+    disp->ext_dispatch.dev_ext[20](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt21(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext21(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[21](device);
+    disp->ext_dispatch.dev_ext[21](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt22(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext22(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[22](device);
+    disp->ext_dispatch.dev_ext[22](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt23(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext23(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[23](device);
+    disp->ext_dispatch.dev_ext[23](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt24(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext24(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[24](device);
+    disp->ext_dispatch.dev_ext[24](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt25(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext25(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[25](device);
+    disp->ext_dispatch.dev_ext[25](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt26(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext26(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[26](device);
+    disp->ext_dispatch.dev_ext[26](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt27(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext27(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[27](device);
+    disp->ext_dispatch.dev_ext[27](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt28(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext28(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[28](device);
+    disp->ext_dispatch.dev_ext[28](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt29(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext29(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[29](device);
+    disp->ext_dispatch.dev_ext[29](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt30(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext30(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[30](device);
+    disp->ext_dispatch.dev_ext[30](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt31(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext31(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[31](device);
+    disp->ext_dispatch.dev_ext[31](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt32(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext32(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[32](device);
+    disp->ext_dispatch.dev_ext[32](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt33(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext33(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[33](device);
+    disp->ext_dispatch.dev_ext[33](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt34(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext34(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[34](device);
+    disp->ext_dispatch.dev_ext[34](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt35(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext35(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[35](device);
+    disp->ext_dispatch.dev_ext[35](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt36(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext36(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[36](device);
+    disp->ext_dispatch.dev_ext[36](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt37(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext37(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[37](device);
+    disp->ext_dispatch.dev_ext[37](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt38(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext38(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[38](device);
+    disp->ext_dispatch.dev_ext[38](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt39(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext39(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[39](device);
+    disp->ext_dispatch.dev_ext[39](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt40(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext40(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[40](device);
+    disp->ext_dispatch.dev_ext[40](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt41(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext41(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[41](device);
+    disp->ext_dispatch.dev_ext[41](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt42(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext42(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[42](device);
+    disp->ext_dispatch.dev_ext[42](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt43(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext43(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[43](device);
+    disp->ext_dispatch.dev_ext[43](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt44(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext44(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[44](device);
+    disp->ext_dispatch.dev_ext[44](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt45(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext45(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[45](device);
+    disp->ext_dispatch.dev_ext[45](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt46(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext46(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[46](device);
+    disp->ext_dispatch.dev_ext[46](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt47(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext47(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[47](device);
+    disp->ext_dispatch.dev_ext[47](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt48(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext48(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[48](device);
+    disp->ext_dispatch.dev_ext[48](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt49(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext49(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[49](device);
+    disp->ext_dispatch.dev_ext[49](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt50(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext50(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[50](device);
+    disp->ext_dispatch.dev_ext[50](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt51(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext51(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[51](device);
+    disp->ext_dispatch.dev_ext[51](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt52(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext52(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[52](device);
+    disp->ext_dispatch.dev_ext[52](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt53(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext53(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[53](device);
+    disp->ext_dispatch.dev_ext[53](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt54(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext54(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[54](device);
+    disp->ext_dispatch.dev_ext[54](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt55(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext55(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[55](device);
+    disp->ext_dispatch.dev_ext[55](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt56(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext56(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[56](device);
+    disp->ext_dispatch.dev_ext[56](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt57(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext57(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[57](device);
+    disp->ext_dispatch.dev_ext[57](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt58(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext58(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[58](device);
+    disp->ext_dispatch.dev_ext[58](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt59(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext59(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[59](device);
+    disp->ext_dispatch.dev_ext[59](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt60(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext60(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[60](device);
+    disp->ext_dispatch.dev_ext[60](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt61(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext61(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[61](device);
+    disp->ext_dispatch.dev_ext[61](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt62(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext62(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[62](device);
+    disp->ext_dispatch.dev_ext[62](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt63(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext63(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[63](device);
+    disp->ext_dispatch.dev_ext[63](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt64(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext64(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[64](device);
+    disp->ext_dispatch.dev_ext[64](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt65(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext65(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[65](device);
+    disp->ext_dispatch.dev_ext[65](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt66(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext66(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[66](device);
+    disp->ext_dispatch.dev_ext[66](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt67(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext67(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[67](device);
+    disp->ext_dispatch.dev_ext[67](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt68(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext68(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[68](device);
+    disp->ext_dispatch.dev_ext[68](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt69(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext69(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[69](device);
+    disp->ext_dispatch.dev_ext[69](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt70(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext70(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[70](device);
+    disp->ext_dispatch.dev_ext[70](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt71(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext71(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[71](device);
+    disp->ext_dispatch.dev_ext[71](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt72(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext72(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[72](device);
+    disp->ext_dispatch.dev_ext[72](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt73(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext73(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[73](device);
+    disp->ext_dispatch.dev_ext[73](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt74(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext74(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[74](device);
+    disp->ext_dispatch.dev_ext[74](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt75(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext75(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[75](device);
+    disp->ext_dispatch.dev_ext[75](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt76(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext76(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[76](device);
+    disp->ext_dispatch.dev_ext[76](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt77(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext77(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[77](device);
+    disp->ext_dispatch.dev_ext[77](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt78(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext78(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[78](device);
+    disp->ext_dispatch.dev_ext[78](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt79(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext79(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[79](device);
+    disp->ext_dispatch.dev_ext[79](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt80(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext80(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[80](device);
+    disp->ext_dispatch.dev_ext[80](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt81(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext81(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[81](device);
+    disp->ext_dispatch.dev_ext[81](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt82(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext82(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[82](device);
+    disp->ext_dispatch.dev_ext[82](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt83(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext83(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[83](device);
+    disp->ext_dispatch.dev_ext[83](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt84(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext84(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[84](device);
+    disp->ext_dispatch.dev_ext[84](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt85(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext85(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[85](device);
+    disp->ext_dispatch.dev_ext[85](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt86(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext86(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[86](device);
+    disp->ext_dispatch.dev_ext[86](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt87(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext87(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[87](device);
+    disp->ext_dispatch.dev_ext[87](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt88(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext88(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[88](device);
+    disp->ext_dispatch.dev_ext[88](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt89(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext89(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[89](device);
+    disp->ext_dispatch.dev_ext[89](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt90(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext90(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[90](device);
+    disp->ext_dispatch.dev_ext[90](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt91(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext91(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[91](device);
+    disp->ext_dispatch.dev_ext[91](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt92(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext92(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[92](device);
+    disp->ext_dispatch.dev_ext[92](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt93(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext93(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[93](device);
+    disp->ext_dispatch.dev_ext[93](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt94(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext94(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[94](device);
+    disp->ext_dispatch.dev_ext[94](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt95(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext95(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[95](device);
+    disp->ext_dispatch.dev_ext[95](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt96(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext96(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[96](device);
+    disp->ext_dispatch.dev_ext[96](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt97(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext97(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[97](device);
+    disp->ext_dispatch.dev_ext[97](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt98(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext98(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[98](device);
+    disp->ext_dispatch.dev_ext[98](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt99(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext99(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[99](device);
+    disp->ext_dispatch.dev_ext[99](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt100(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext100(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[100](device);
+    disp->ext_dispatch.dev_ext[100](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt101(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext101(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[101](device);
+    disp->ext_dispatch.dev_ext[101](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt102(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext102(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[102](device);
+    disp->ext_dispatch.dev_ext[102](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt103(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext103(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[103](device);
+    disp->ext_dispatch.dev_ext[103](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt104(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext104(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[104](device);
+    disp->ext_dispatch.dev_ext[104](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt105(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext105(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[105](device);
+    disp->ext_dispatch.dev_ext[105](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt106(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext106(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[106](device);
+    disp->ext_dispatch.dev_ext[106](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt107(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext107(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[107](device);
+    disp->ext_dispatch.dev_ext[107](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt108(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext108(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[108](device);
+    disp->ext_dispatch.dev_ext[108](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt109(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext109(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[109](device);
+    disp->ext_dispatch.dev_ext[109](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt110(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext110(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[110](device);
+    disp->ext_dispatch.dev_ext[110](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt111(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext111(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[111](device);
+    disp->ext_dispatch.dev_ext[111](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt112(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext112(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[112](device);
+    disp->ext_dispatch.dev_ext[112](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt113(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext113(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[113](device);
+    disp->ext_dispatch.dev_ext[113](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt114(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext114(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[114](device);
+    disp->ext_dispatch.dev_ext[114](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt115(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext115(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[115](device);
+    disp->ext_dispatch.dev_ext[115](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt116(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext116(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[116](device);
+    disp->ext_dispatch.dev_ext[116](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt117(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext117(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[117](device);
+    disp->ext_dispatch.dev_ext[117](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt118(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext118(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[118](device);
+    disp->ext_dispatch.dev_ext[118](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt119(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext119(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[119](device);
+    disp->ext_dispatch.dev_ext[119](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt120(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext120(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[120](device);
+    disp->ext_dispatch.dev_ext[120](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt121(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext121(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[121](device);
+    disp->ext_dispatch.dev_ext[121](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt122(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext122(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[122](device);
+    disp->ext_dispatch.dev_ext[122](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt123(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext123(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[123](device);
+    disp->ext_dispatch.dev_ext[123](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt124(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext124(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[124](device);
+    disp->ext_dispatch.dev_ext[124](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt125(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext125(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[125](device);
+    disp->ext_dispatch.dev_ext[125](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt126(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext126(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[126](device);
+    disp->ext_dispatch.dev_ext[126](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt127(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext127(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[127](device);
+    disp->ext_dispatch.dev_ext[127](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt128(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext128(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[128](device);
+    disp->ext_dispatch.dev_ext[128](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt129(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext129(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[129](device);
+    disp->ext_dispatch.dev_ext[129](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt130(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext130(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[130](device);
+    disp->ext_dispatch.dev_ext[130](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt131(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext131(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[131](device);
+    disp->ext_dispatch.dev_ext[131](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt132(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext132(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[132](device);
+    disp->ext_dispatch.dev_ext[132](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt133(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext133(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[133](device);
+    disp->ext_dispatch.dev_ext[133](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt134(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext134(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[134](device);
+    disp->ext_dispatch.dev_ext[134](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt135(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext135(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[135](device);
+    disp->ext_dispatch.dev_ext[135](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt136(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext136(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[136](device);
+    disp->ext_dispatch.dev_ext[136](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt137(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext137(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[137](device);
+    disp->ext_dispatch.dev_ext[137](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt138(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext138(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[138](device);
+    disp->ext_dispatch.dev_ext[138](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt139(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext139(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[139](device);
+    disp->ext_dispatch.dev_ext[139](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt140(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext140(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[140](device);
+    disp->ext_dispatch.dev_ext[140](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt141(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext141(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[141](device);
+    disp->ext_dispatch.dev_ext[141](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt142(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext142(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[142](device);
+    disp->ext_dispatch.dev_ext[142](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt143(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext143(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[143](device);
+    disp->ext_dispatch.dev_ext[143](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt144(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext144(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[144](device);
+    disp->ext_dispatch.dev_ext[144](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt145(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext145(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[145](device);
+    disp->ext_dispatch.dev_ext[145](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt146(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext146(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[146](device);
+    disp->ext_dispatch.dev_ext[146](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt147(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext147(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[147](device);
+    disp->ext_dispatch.dev_ext[147](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt148(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext148(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[148](device);
+    disp->ext_dispatch.dev_ext[148](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt149(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext149(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[149](device);
+    disp->ext_dispatch.dev_ext[149](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt150(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext150(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[150](device);
+    disp->ext_dispatch.dev_ext[150](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt151(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext151(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[151](device);
+    disp->ext_dispatch.dev_ext[151](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt152(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext152(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[152](device);
+    disp->ext_dispatch.dev_ext[152](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt153(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext153(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[153](device);
+    disp->ext_dispatch.dev_ext[153](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt154(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext154(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[154](device);
+    disp->ext_dispatch.dev_ext[154](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt155(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext155(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[155](device);
+    disp->ext_dispatch.dev_ext[155](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt156(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext156(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[156](device);
+    disp->ext_dispatch.dev_ext[156](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt157(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext157(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[157](device);
+    disp->ext_dispatch.dev_ext[157](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt158(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext158(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[158](device);
+    disp->ext_dispatch.dev_ext[158](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt159(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext159(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[159](device);
+    disp->ext_dispatch.dev_ext[159](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt160(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext160(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[160](device);
+    disp->ext_dispatch.dev_ext[160](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt161(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext161(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[161](device);
+    disp->ext_dispatch.dev_ext[161](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt162(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext162(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[162](device);
+    disp->ext_dispatch.dev_ext[162](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt163(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext163(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[163](device);
+    disp->ext_dispatch.dev_ext[163](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt164(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext164(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[164](device);
+    disp->ext_dispatch.dev_ext[164](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt165(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext165(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[165](device);
+    disp->ext_dispatch.dev_ext[165](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt166(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext166(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[166](device);
+    disp->ext_dispatch.dev_ext[166](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt167(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext167(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[167](device);
+    disp->ext_dispatch.dev_ext[167](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt168(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext168(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[168](device);
+    disp->ext_dispatch.dev_ext[168](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt169(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext169(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[169](device);
+    disp->ext_dispatch.dev_ext[169](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt170(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext170(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[170](device);
+    disp->ext_dispatch.dev_ext[170](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt171(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext171(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[171](device);
+    disp->ext_dispatch.dev_ext[171](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt172(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext172(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[172](device);
+    disp->ext_dispatch.dev_ext[172](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt173(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext173(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[173](device);
+    disp->ext_dispatch.dev_ext[173](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt174(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext174(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[174](device);
+    disp->ext_dispatch.dev_ext[174](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt175(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext175(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[175](device);
+    disp->ext_dispatch.dev_ext[175](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt176(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext176(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[176](device);
+    disp->ext_dispatch.dev_ext[176](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt177(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext177(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[177](device);
+    disp->ext_dispatch.dev_ext[177](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt178(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext178(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[178](device);
+    disp->ext_dispatch.dev_ext[178](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt179(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext179(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[179](device);
+    disp->ext_dispatch.dev_ext[179](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt180(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext180(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[180](device);
+    disp->ext_dispatch.dev_ext[180](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt181(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext181(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[181](device);
+    disp->ext_dispatch.dev_ext[181](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt182(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext182(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[182](device);
+    disp->ext_dispatch.dev_ext[182](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt183(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext183(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[183](device);
+    disp->ext_dispatch.dev_ext[183](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt184(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext184(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[184](device);
+    disp->ext_dispatch.dev_ext[184](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt185(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext185(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[185](device);
+    disp->ext_dispatch.dev_ext[185](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt186(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext186(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[186](device);
+    disp->ext_dispatch.dev_ext[186](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt187(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext187(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[187](device);
+    disp->ext_dispatch.dev_ext[187](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt188(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext188(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[188](device);
+    disp->ext_dispatch.dev_ext[188](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt189(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext189(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[189](device);
+    disp->ext_dispatch.dev_ext[189](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt190(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext190(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[190](device);
+    disp->ext_dispatch.dev_ext[190](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt191(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext191(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[191](device);
+    disp->ext_dispatch.dev_ext[191](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt192(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext192(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[192](device);
+    disp->ext_dispatch.dev_ext[192](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt193(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext193(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[193](device);
+    disp->ext_dispatch.dev_ext[193](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt194(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext194(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[194](device);
+    disp->ext_dispatch.dev_ext[194](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt195(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext195(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[195](device);
+    disp->ext_dispatch.dev_ext[195](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt196(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext196(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[196](device);
+    disp->ext_dispatch.dev_ext[196](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt197(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext197(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[197](device);
+    disp->ext_dispatch.dev_ext[197](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt198(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext198(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[198](device);
+    disp->ext_dispatch.dev_ext[198](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt199(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext199(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[199](device);
+    disp->ext_dispatch.dev_ext[199](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt200(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext200(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[200](device);
+    disp->ext_dispatch.dev_ext[200](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt201(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext201(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[201](device);
+    disp->ext_dispatch.dev_ext[201](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt202(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext202(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[202](device);
+    disp->ext_dispatch.dev_ext[202](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt203(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext203(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[203](device);
+    disp->ext_dispatch.dev_ext[203](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt204(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext204(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[204](device);
+    disp->ext_dispatch.dev_ext[204](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt205(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext205(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[205](device);
+    disp->ext_dispatch.dev_ext[205](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt206(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext206(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[206](device);
+    disp->ext_dispatch.dev_ext[206](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt207(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext207(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[207](device);
+    disp->ext_dispatch.dev_ext[207](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt208(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext208(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[208](device);
+    disp->ext_dispatch.dev_ext[208](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt209(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext209(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[209](device);
+    disp->ext_dispatch.dev_ext[209](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt210(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext210(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[210](device);
+    disp->ext_dispatch.dev_ext[210](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt211(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext211(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[211](device);
+    disp->ext_dispatch.dev_ext[211](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt212(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext212(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[212](device);
+    disp->ext_dispatch.dev_ext[212](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt213(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext213(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[213](device);
+    disp->ext_dispatch.dev_ext[213](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt214(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext214(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[214](device);
+    disp->ext_dispatch.dev_ext[214](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt215(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext215(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[215](device);
+    disp->ext_dispatch.dev_ext[215](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt216(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext216(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[216](device);
+    disp->ext_dispatch.dev_ext[216](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt217(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext217(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[217](device);
+    disp->ext_dispatch.dev_ext[217](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt218(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext218(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[218](device);
+    disp->ext_dispatch.dev_ext[218](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt219(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext219(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[219](device);
+    disp->ext_dispatch.dev_ext[219](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt220(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext220(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[220](device);
+    disp->ext_dispatch.dev_ext[220](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt221(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext221(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[221](device);
+    disp->ext_dispatch.dev_ext[221](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt222(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext222(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[222](device);
+    disp->ext_dispatch.dev_ext[222](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt223(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext223(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[223](device);
+    disp->ext_dispatch.dev_ext[223](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt224(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext224(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[224](device);
+    disp->ext_dispatch.dev_ext[224](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt225(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext225(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[225](device);
+    disp->ext_dispatch.dev_ext[225](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt226(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext226(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[226](device);
+    disp->ext_dispatch.dev_ext[226](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt227(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext227(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[227](device);
+    disp->ext_dispatch.dev_ext[227](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt228(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext228(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[228](device);
+    disp->ext_dispatch.dev_ext[228](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt229(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext229(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[229](device);
+    disp->ext_dispatch.dev_ext[229](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt230(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext230(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[230](device);
+    disp->ext_dispatch.dev_ext[230](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt231(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext231(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[231](device);
+    disp->ext_dispatch.dev_ext[231](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt232(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext232(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[232](device);
+    disp->ext_dispatch.dev_ext[232](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt233(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext233(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[233](device);
+    disp->ext_dispatch.dev_ext[233](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt234(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext234(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[234](device);
+    disp->ext_dispatch.dev_ext[234](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt235(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext235(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[235](device);
+    disp->ext_dispatch.dev_ext[235](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt236(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext236(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[236](device);
+    disp->ext_dispatch.dev_ext[236](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt237(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext237(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[237](device);
+    disp->ext_dispatch.dev_ext[237](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt238(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext238(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[238](device);
+    disp->ext_dispatch.dev_ext[238](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt239(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext239(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[239](device);
+    disp->ext_dispatch.dev_ext[239](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt240(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext240(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[240](device);
+    disp->ext_dispatch.dev_ext[240](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt241(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext241(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[241](device);
+    disp->ext_dispatch.dev_ext[241](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt242(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext242(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[242](device);
+    disp->ext_dispatch.dev_ext[242](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt243(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext243(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[243](device);
+    disp->ext_dispatch.dev_ext[243](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt244(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext244(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[244](device);
+    disp->ext_dispatch.dev_ext[244](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt245(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext245(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[245](device);
+    disp->ext_dispatch.dev_ext[245](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt246(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext246(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[246](device);
+    disp->ext_dispatch.dev_ext[246](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt247(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext247(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[247](device);
+    disp->ext_dispatch.dev_ext[247](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt248(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext248(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[248](device);
+    disp->ext_dispatch.dev_ext[248](device);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDevExt249(VkDevice device) {
+VKAPI_ATTR void VKAPI_CALL vkdev_ext249(VkDevice device) {
     const struct loader_dev_dispatch_table *disp;
     disp = loader_get_dev_dispatch(device);
-    disp->ext_dispatch.DevExt[249](device);
+    disp->ext_dispatch.dev_ext[249](device);
 }
 
 void *loader_get_dev_ext_trampoline(uint32_t index) {
     switch (index) {
     case 0:
-        return vkDevExt0;
+        return vkdev_ext0;
     case 1:
-        return vkDevExt1;
+        return vkdev_ext1;
     case 2:
-        return vkDevExt2;
+        return vkdev_ext2;
     case 3:
-        return vkDevExt3;
+        return vkdev_ext3;
     case 4:
-        return vkDevExt4;
+        return vkdev_ext4;
     case 5:
-        return vkDevExt5;
+        return vkdev_ext5;
     case 6:
-        return vkDevExt6;
+        return vkdev_ext6;
     case 7:
-        return vkDevExt7;
+        return vkdev_ext7;
     case 8:
-        return vkDevExt8;
+        return vkdev_ext8;
     case 9:
-        return vkDevExt9;
+        return vkdev_ext9;
     case 10:
-        return vkDevExt10;
+        return vkdev_ext10;
     case 11:
-        return vkDevExt11;
+        return vkdev_ext11;
     case 12:
-        return vkDevExt12;
+        return vkdev_ext12;
     case 13:
-        return vkDevExt13;
+        return vkdev_ext13;
     case 14:
-        return vkDevExt14;
+        return vkdev_ext14;
     case 15:
-        return vkDevExt15;
+        return vkdev_ext15;
     case 16:
-        return vkDevExt16;
+        return vkdev_ext16;
     case 17:
-        return vkDevExt17;
+        return vkdev_ext17;
     case 18:
-        return vkDevExt18;
+        return vkdev_ext18;
     case 19:
-        return vkDevExt19;
+        return vkdev_ext19;
     case 20:
-        return vkDevExt20;
+        return vkdev_ext20;
     case 21:
-        return vkDevExt21;
+        return vkdev_ext21;
     case 22:
-        return vkDevExt22;
+        return vkdev_ext22;
     case 23:
-        return vkDevExt23;
+        return vkdev_ext23;
     case 24:
-        return vkDevExt24;
+        return vkdev_ext24;
     case 25:
-        return vkDevExt25;
+        return vkdev_ext25;
     case 26:
-        return vkDevExt26;
+        return vkdev_ext26;
     case 27:
-        return vkDevExt27;
+        return vkdev_ext27;
     case 28:
-        return vkDevExt28;
+        return vkdev_ext28;
     case 29:
-        return vkDevExt29;
+        return vkdev_ext29;
     case 30:
-        return vkDevExt30;
+        return vkdev_ext30;
     case 31:
-        return vkDevExt31;
+        return vkdev_ext31;
     case 32:
-        return vkDevExt32;
+        return vkdev_ext32;
     case 33:
-        return vkDevExt33;
+        return vkdev_ext33;
     case 34:
-        return vkDevExt34;
+        return vkdev_ext34;
     case 35:
-        return vkDevExt35;
+        return vkdev_ext35;
     case 36:
-        return vkDevExt36;
+        return vkdev_ext36;
     case 37:
-        return vkDevExt37;
+        return vkdev_ext37;
     case 38:
-        return vkDevExt38;
+        return vkdev_ext38;
     case 39:
-        return vkDevExt39;
+        return vkdev_ext39;
     case 40:
-        return vkDevExt40;
+        return vkdev_ext40;
     case 41:
-        return vkDevExt41;
+        return vkdev_ext41;
     case 42:
-        return vkDevExt42;
+        return vkdev_ext42;
     case 43:
-        return vkDevExt43;
+        return vkdev_ext43;
     case 44:
-        return vkDevExt44;
+        return vkdev_ext44;
     case 45:
-        return vkDevExt45;
+        return vkdev_ext45;
     case 46:
-        return vkDevExt46;
+        return vkdev_ext46;
     case 47:
-        return vkDevExt47;
+        return vkdev_ext47;
     case 48:
-        return vkDevExt48;
+        return vkdev_ext48;
     case 49:
-        return vkDevExt49;
+        return vkdev_ext49;
     case 50:
-        return vkDevExt50;
+        return vkdev_ext50;
     case 51:
-        return vkDevExt51;
+        return vkdev_ext51;
     case 52:
-        return vkDevExt52;
+        return vkdev_ext52;
     case 53:
-        return vkDevExt53;
+        return vkdev_ext53;
     case 54:
-        return vkDevExt54;
+        return vkdev_ext54;
     case 55:
-        return vkDevExt55;
+        return vkdev_ext55;
     case 56:
-        return vkDevExt56;
+        return vkdev_ext56;
     case 57:
-        return vkDevExt57;
+        return vkdev_ext57;
     case 58:
-        return vkDevExt58;
+        return vkdev_ext58;
     case 59:
-        return vkDevExt59;
+        return vkdev_ext59;
     case 60:
-        return vkDevExt60;
+        return vkdev_ext60;
     case 61:
-        return vkDevExt61;
+        return vkdev_ext61;
     case 62:
-        return vkDevExt62;
+        return vkdev_ext62;
     case 63:
-        return vkDevExt63;
+        return vkdev_ext63;
     case 64:
-        return vkDevExt64;
+        return vkdev_ext64;
     case 65:
-        return vkDevExt65;
+        return vkdev_ext65;
     case 66:
-        return vkDevExt66;
+        return vkdev_ext66;
     case 67:
-        return vkDevExt67;
+        return vkdev_ext67;
     case 68:
-        return vkDevExt68;
+        return vkdev_ext68;
     case 69:
-        return vkDevExt69;
+        return vkdev_ext69;
     case 70:
-        return vkDevExt70;
+        return vkdev_ext70;
     case 71:
-        return vkDevExt71;
+        return vkdev_ext71;
     case 72:
-        return vkDevExt72;
+        return vkdev_ext72;
     case 73:
-        return vkDevExt73;
+        return vkdev_ext73;
     case 74:
-        return vkDevExt74;
+        return vkdev_ext74;
     case 75:
-        return vkDevExt75;
+        return vkdev_ext75;
     case 76:
-        return vkDevExt76;
+        return vkdev_ext76;
     case 77:
-        return vkDevExt77;
+        return vkdev_ext77;
     case 78:
-        return vkDevExt78;
+        return vkdev_ext78;
     case 79:
-        return vkDevExt79;
+        return vkdev_ext79;
     case 80:
-        return vkDevExt80;
+        return vkdev_ext80;
     case 81:
-        return vkDevExt81;
+        return vkdev_ext81;
     case 82:
-        return vkDevExt82;
+        return vkdev_ext82;
     case 83:
-        return vkDevExt83;
+        return vkdev_ext83;
     case 84:
-        return vkDevExt84;
+        return vkdev_ext84;
     case 85:
-        return vkDevExt85;
+        return vkdev_ext85;
     case 86:
-        return vkDevExt86;
+        return vkdev_ext86;
     case 87:
-        return vkDevExt87;
+        return vkdev_ext87;
     case 88:
-        return vkDevExt88;
+        return vkdev_ext88;
     case 89:
-        return vkDevExt89;
+        return vkdev_ext89;
     case 90:
-        return vkDevExt90;
+        return vkdev_ext90;
     case 91:
-        return vkDevExt91;
+        return vkdev_ext91;
     case 92:
-        return vkDevExt92;
+        return vkdev_ext92;
     case 93:
-        return vkDevExt93;
+        return vkdev_ext93;
     case 94:
-        return vkDevExt94;
+        return vkdev_ext94;
     case 95:
-        return vkDevExt95;
+        return vkdev_ext95;
     case 96:
-        return vkDevExt96;
+        return vkdev_ext96;
     case 97:
-        return vkDevExt97;
+        return vkdev_ext97;
     case 98:
-        return vkDevExt98;
+        return vkdev_ext98;
     case 99:
-        return vkDevExt99;
+        return vkdev_ext99;
     case 100:
-        return vkDevExt100;
+        return vkdev_ext100;
     case 101:
-        return vkDevExt101;
+        return vkdev_ext101;
     case 102:
-        return vkDevExt102;
+        return vkdev_ext102;
     case 103:
-        return vkDevExt103;
+        return vkdev_ext103;
     case 104:
-        return vkDevExt104;
+        return vkdev_ext104;
     case 105:
-        return vkDevExt105;
+        return vkdev_ext105;
     case 106:
-        return vkDevExt106;
+        return vkdev_ext106;
     case 107:
-        return vkDevExt107;
+        return vkdev_ext107;
     case 108:
-        return vkDevExt108;
+        return vkdev_ext108;
     case 109:
-        return vkDevExt109;
+        return vkdev_ext109;
     case 110:
-        return vkDevExt110;
+        return vkdev_ext110;
     case 111:
-        return vkDevExt111;
+        return vkdev_ext111;
     case 112:
-        return vkDevExt112;
+        return vkdev_ext112;
     case 113:
-        return vkDevExt113;
+        return vkdev_ext113;
     case 114:
-        return vkDevExt114;
+        return vkdev_ext114;
     case 115:
-        return vkDevExt115;
+        return vkdev_ext115;
     case 116:
-        return vkDevExt116;
+        return vkdev_ext116;
     case 117:
-        return vkDevExt117;
+        return vkdev_ext117;
     case 118:
-        return vkDevExt118;
+        return vkdev_ext118;
     case 119:
-        return vkDevExt119;
+        return vkdev_ext119;
     case 120:
-        return vkDevExt120;
+        return vkdev_ext120;
     case 121:
-        return vkDevExt121;
+        return vkdev_ext121;
     case 122:
-        return vkDevExt122;
+        return vkdev_ext122;
     case 123:
-        return vkDevExt123;
+        return vkdev_ext123;
     case 124:
-        return vkDevExt124;
+        return vkdev_ext124;
     case 125:
-        return vkDevExt125;
+        return vkdev_ext125;
     case 126:
-        return vkDevExt126;
+        return vkdev_ext126;
     case 127:
-        return vkDevExt127;
+        return vkdev_ext127;
     case 128:
-        return vkDevExt128;
+        return vkdev_ext128;
     case 129:
-        return vkDevExt129;
+        return vkdev_ext129;
     case 130:
-        return vkDevExt130;
+        return vkdev_ext130;
     case 131:
-        return vkDevExt131;
+        return vkdev_ext131;
     case 132:
-        return vkDevExt132;
+        return vkdev_ext132;
     case 133:
-        return vkDevExt133;
+        return vkdev_ext133;
     case 134:
-        return vkDevExt134;
+        return vkdev_ext134;
     case 135:
-        return vkDevExt135;
+        return vkdev_ext135;
     case 136:
-        return vkDevExt136;
+        return vkdev_ext136;
     case 137:
-        return vkDevExt137;
+        return vkdev_ext137;
     case 138:
-        return vkDevExt138;
+        return vkdev_ext138;
     case 139:
-        return vkDevExt139;
+        return vkdev_ext139;
     case 140:
-        return vkDevExt140;
+        return vkdev_ext140;
     case 141:
-        return vkDevExt141;
+        return vkdev_ext141;
     case 142:
-        return vkDevExt142;
+        return vkdev_ext142;
     case 143:
-        return vkDevExt143;
+        return vkdev_ext143;
     case 144:
-        return vkDevExt144;
+        return vkdev_ext144;
     case 145:
-        return vkDevExt145;
+        return vkdev_ext145;
     case 146:
-        return vkDevExt146;
+        return vkdev_ext146;
     case 147:
-        return vkDevExt147;
+        return vkdev_ext147;
     case 148:
-        return vkDevExt148;
+        return vkdev_ext148;
     case 149:
-        return vkDevExt149;
+        return vkdev_ext149;
     case 150:
-        return vkDevExt150;
+        return vkdev_ext150;
     case 151:
-        return vkDevExt151;
+        return vkdev_ext151;
     case 152:
-        return vkDevExt152;
+        return vkdev_ext152;
     case 153:
-        return vkDevExt153;
+        return vkdev_ext153;
     case 154:
-        return vkDevExt154;
+        return vkdev_ext154;
     case 155:
-        return vkDevExt155;
+        return vkdev_ext155;
     case 156:
-        return vkDevExt156;
+        return vkdev_ext156;
     case 157:
-        return vkDevExt157;
+        return vkdev_ext157;
     case 158:
-        return vkDevExt158;
+        return vkdev_ext158;
     case 159:
-        return vkDevExt159;
+        return vkdev_ext159;
     case 160:
-        return vkDevExt160;
+        return vkdev_ext160;
     case 161:
-        return vkDevExt161;
+        return vkdev_ext161;
     case 162:
-        return vkDevExt162;
+        return vkdev_ext162;
     case 163:
-        return vkDevExt163;
+        return vkdev_ext163;
     case 164:
-        return vkDevExt164;
+        return vkdev_ext164;
     case 165:
-        return vkDevExt165;
+        return vkdev_ext165;
     case 166:
-        return vkDevExt166;
+        return vkdev_ext166;
     case 167:
-        return vkDevExt167;
+        return vkdev_ext167;
     case 168:
-        return vkDevExt168;
+        return vkdev_ext168;
     case 169:
-        return vkDevExt169;
+        return vkdev_ext169;
     case 170:
-        return vkDevExt170;
+        return vkdev_ext170;
     case 171:
-        return vkDevExt171;
+        return vkdev_ext171;
     case 172:
-        return vkDevExt172;
+        return vkdev_ext172;
     case 173:
-        return vkDevExt173;
+        return vkdev_ext173;
     case 174:
-        return vkDevExt174;
+        return vkdev_ext174;
     case 175:
-        return vkDevExt175;
+        return vkdev_ext175;
     case 176:
-        return vkDevExt176;
+        return vkdev_ext176;
     case 177:
-        return vkDevExt177;
+        return vkdev_ext177;
     case 178:
-        return vkDevExt178;
+        return vkdev_ext178;
     case 179:
-        return vkDevExt179;
+        return vkdev_ext179;
     case 180:
-        return vkDevExt180;
+        return vkdev_ext180;
     case 181:
-        return vkDevExt181;
+        return vkdev_ext181;
     case 182:
-        return vkDevExt182;
+        return vkdev_ext182;
     case 183:
-        return vkDevExt183;
+        return vkdev_ext183;
     case 184:
-        return vkDevExt184;
+        return vkdev_ext184;
     case 185:
-        return vkDevExt185;
+        return vkdev_ext185;
     case 186:
-        return vkDevExt186;
+        return vkdev_ext186;
     case 187:
-        return vkDevExt187;
+        return vkdev_ext187;
     case 188:
-        return vkDevExt188;
+        return vkdev_ext188;
     case 189:
-        return vkDevExt189;
+        return vkdev_ext189;
     case 190:
-        return vkDevExt190;
+        return vkdev_ext190;
     case 191:
-        return vkDevExt191;
+        return vkdev_ext191;
     case 192:
-        return vkDevExt192;
+        return vkdev_ext192;
     case 193:
-        return vkDevExt193;
+        return vkdev_ext193;
     case 194:
-        return vkDevExt194;
+        return vkdev_ext194;
     case 195:
-        return vkDevExt195;
+        return vkdev_ext195;
     case 196:
-        return vkDevExt196;
+        return vkdev_ext196;
     case 197:
-        return vkDevExt197;
+        return vkdev_ext197;
     case 198:
-        return vkDevExt198;
+        return vkdev_ext198;
     case 199:
-        return vkDevExt199;
+        return vkdev_ext199;
     case 200:
-        return vkDevExt200;
+        return vkdev_ext200;
     case 201:
-        return vkDevExt201;
+        return vkdev_ext201;
     case 202:
-        return vkDevExt202;
+        return vkdev_ext202;
     case 203:
-        return vkDevExt203;
+        return vkdev_ext203;
     case 204:
-        return vkDevExt204;
+        return vkdev_ext204;
     case 205:
-        return vkDevExt205;
+        return vkdev_ext205;
     case 206:
-        return vkDevExt206;
+        return vkdev_ext206;
     case 207:
-        return vkDevExt207;
+        return vkdev_ext207;
     case 208:
-        return vkDevExt208;
+        return vkdev_ext208;
     case 209:
-        return vkDevExt209;
+        return vkdev_ext209;
     case 210:
-        return vkDevExt210;
+        return vkdev_ext210;
     case 211:
-        return vkDevExt211;
+        return vkdev_ext211;
     case 212:
-        return vkDevExt212;
+        return vkdev_ext212;
     case 213:
-        return vkDevExt213;
+        return vkdev_ext213;
     case 214:
-        return vkDevExt214;
+        return vkdev_ext214;
     case 215:
-        return vkDevExt215;
+        return vkdev_ext215;
     case 216:
-        return vkDevExt216;
+        return vkdev_ext216;
     case 217:
-        return vkDevExt217;
+        return vkdev_ext217;
     case 218:
-        return vkDevExt218;
+        return vkdev_ext218;
     case 219:
-        return vkDevExt219;
+        return vkdev_ext219;
     case 220:
-        return vkDevExt220;
+        return vkdev_ext220;
     case 221:
-        return vkDevExt221;
+        return vkdev_ext221;
     case 222:
-        return vkDevExt222;
+        return vkdev_ext222;
     case 223:
-        return vkDevExt223;
+        return vkdev_ext223;
     case 224:
-        return vkDevExt224;
+        return vkdev_ext224;
     case 225:
-        return vkDevExt225;
+        return vkdev_ext225;
     case 226:
-        return vkDevExt226;
+        return vkdev_ext226;
     case 227:
-        return vkDevExt227;
+        return vkdev_ext227;
     case 228:
-        return vkDevExt228;
+        return vkdev_ext228;
     case 229:
-        return vkDevExt229;
+        return vkdev_ext229;
     case 230:
-        return vkDevExt230;
+        return vkdev_ext230;
     case 231:
-        return vkDevExt231;
+        return vkdev_ext231;
     case 232:
-        return vkDevExt232;
+        return vkdev_ext232;
     case 233:
-        return vkDevExt233;
+        return vkdev_ext233;
     case 234:
-        return vkDevExt234;
+        return vkdev_ext234;
     case 235:
-        return vkDevExt235;
+        return vkdev_ext235;
     case 236:
-        return vkDevExt236;
+        return vkdev_ext236;
     case 237:
-        return vkDevExt237;
+        return vkdev_ext237;
     case 238:
-        return vkDevExt238;
+        return vkdev_ext238;
     case 239:
-        return vkDevExt239;
+        return vkdev_ext239;
     case 240:
-        return vkDevExt240;
+        return vkdev_ext240;
     case 241:
-        return vkDevExt241;
+        return vkdev_ext241;
     case 242:
-        return vkDevExt242;
+        return vkdev_ext242;
     case 243:
-        return vkDevExt243;
+        return vkdev_ext243;
     case 244:
-        return vkDevExt244;
+        return vkdev_ext244;
     case 245:
-        return vkDevExt245;
+        return vkdev_ext245;
     case 246:
-        return vkDevExt246;
+        return vkdev_ext246;
     case 247:
-        return vkDevExt247;
+        return vkdev_ext247;
     case 248:
-        return vkDevExt248;
+        return vkdev_ext248;
     case 249:
-        return vkDevExt249;
+        return vkdev_ext249;
     }
     return NULL;
 }
diff --git a/loader/loader.c b/loader/loader.c
index 803c510..3a4b6d6 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -3254,7 +3254,7 @@ static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst,
         gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr(
             dev->device, funcName);
         if (gdpa_value != NULL)
-            dev->loader_dispatch.ext_dispatch.DevExt[idx] =
+            dev->loader_dispatch.ext_dispatch.dev_ext[idx] =
                 (PFN_vkDevExt)gdpa_value;
     } else {
         for (uint32_t i = 0; i < inst->total_icd_count; i++) {
@@ -3265,7 +3265,7 @@ static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst,
                     ldev->loader_dispatch.core_dispatch.GetDeviceProcAddr(
                         ldev->device, funcName);
                 if (gdpa_value != NULL)
-                    ldev->loader_dispatch.ext_dispatch.DevExt[idx] =
+                    ldev->loader_dispatch.ext_dispatch.dev_ext[idx] =
                         (PFN_vkDevExt)gdpa_value;
                 ldev = ldev->next;
             }
diff --git a/loader/loader.h b/loader/loader.h
index 7485654..cc9c98f 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -144,9 +144,9 @@ struct loader_dispatch_hash_list {
 };
 
 #define MAX_NUM_DEV_EXTS 250
-// loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.DevExt have one
-// to one
-// correspondence; one loader_dispatch_hash_entry for one DevExt dispatch entry.
+// loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.dev_ext have
+// one to one correspondence; one loader_dispatch_hash_entry for one dev_ext
+// dispatch entry.
 // Also have a one to one correspondence with functions in dev_ext_trampoline.c
 struct loader_dispatch_hash_entry {
     char *func_name;
@@ -155,7 +155,7 @@ struct loader_dispatch_hash_entry {
 
 typedef void(VKAPI_PTR *PFN_vkDevExt)(VkDevice device);
 struct loader_dev_ext_dispatch_table {
-    PFN_vkDevExt DevExt[MAX_NUM_DEV_EXTS];
+    PFN_vkDevExt dev_ext[MAX_NUM_DEV_EXTS];
 };
 
 struct loader_dev_dispatch_table {
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 2b4d6d4..cb84b87 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -45,7 +45,7 @@ loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table,
                                   PFN_vkGetDeviceProcAddr gpa, VkDevice dev) {
     VkLayerDispatchTable *table = &dev_table->core_dispatch;
     for (uint32_t i = 0; i < MAX_NUM_DEV_EXTS; i++)
-        dev_table->ext_dispatch.DevExt[i] = (PFN_vkDevExt)vkDevExtError;
+        dev_table->ext_dispatch.dev_ext[i] = (PFN_vkDevExt)vkDevExtError;
 
     table->GetDeviceProcAddr =
         (PFN_vkGetDeviceProcAddr)gpa(dev, "vkGetDeviceProcAddr");