Home | History | Annotate | Download | only in loader 
      1 /*
      2  * Copyright (c) 2015-2016 The Khronos Group Inc.
      3  * Copyright (c) 2015-2016 Valve Corporation
      4  * Copyright (c) 2015-2016 LunarG, Inc.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a copy
      7  * of this software and/or associated documentation files (the "Materials"), to
      8  * deal in the Materials without restriction, including without limitation the
      9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
     10  * sell copies of the Materials, and to permit persons to whom the Materials are
     11  * furnished to do so, subject to the following conditions:
     12  *
     13  * The above copyright notice(s) and this permission notice shall be included in
     14  * all copies or substantial portions of the Materials.
     15  *
     16  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     19  *
     20  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
     21  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
     22  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
     23  * USE OR OTHER DEALINGS IN THE MATERIALS.
     24  *
     25  * Author: Jon Ashburn <jon (at) lunarg.com>
     26  */
     27 
     28 #include "vk_loader_platform.h"
     29 #include "loader.h"
     30 #if defined(__linux__)
     31 #pragma GCC optimize(3) // force gcc to use tail-calls
     32 #endif
     33 
     34 VKAPI_ATTR void VKAPI_CALL vkDevExt0(VkDevice device) {
     35     const struct loader_dev_dispatch_table *disp;
     36     disp = loader_get_dev_dispatch(device);
     37     disp->ext_dispatch.DevExt[0](device);
     38 }
     39 
     40 VKAPI_ATTR void VKAPI_CALL vkDevExt1(VkDevice device) {
     41     const struct loader_dev_dispatch_table *disp;
     42     disp = loader_get_dev_dispatch(device);
     43     disp->ext_dispatch.DevExt[1](device);
     44 }
     45 
     46 VKAPI_ATTR void VKAPI_CALL vkDevExt2(VkDevice device) {
     47     const struct loader_dev_dispatch_table *disp;
     48     disp = loader_get_dev_dispatch(device);
     49     disp->ext_dispatch.DevExt[2](device);
     50 }
     51 
     52 VKAPI_ATTR void VKAPI_CALL vkDevExt3(VkDevice device) {
     53     const struct loader_dev_dispatch_table *disp;
     54     disp = loader_get_dev_dispatch(device);
     55     disp->ext_dispatch.DevExt[3](device);
     56 }
     57 
     58 VKAPI_ATTR void VKAPI_CALL vkDevExt4(VkDevice device) {
     59     const struct loader_dev_dispatch_table *disp;
     60     disp = loader_get_dev_dispatch(device);
     61     disp->ext_dispatch.DevExt[4](device);
     62 }
     63 
     64 VKAPI_ATTR void VKAPI_CALL vkDevExt5(VkDevice device) {
     65     const struct loader_dev_dispatch_table *disp;
     66     disp = loader_get_dev_dispatch(device);
     67     disp->ext_dispatch.DevExt[5](device);
     68 }
     69 
     70 VKAPI_ATTR void VKAPI_CALL vkDevExt6(VkDevice device) {
     71     const struct loader_dev_dispatch_table *disp;
     72     disp = loader_get_dev_dispatch(device);
     73     disp->ext_dispatch.DevExt[6](device);
     74 }
     75 
     76 VKAPI_ATTR void VKAPI_CALL vkDevExt7(VkDevice device) {
     77     const struct loader_dev_dispatch_table *disp;
     78     disp = loader_get_dev_dispatch(device);
     79     disp->ext_dispatch.DevExt[7](device);
     80 }
     81 
     82 VKAPI_ATTR void VKAPI_CALL vkDevExt8(VkDevice device) {
     83     const struct loader_dev_dispatch_table *disp;
     84     disp = loader_get_dev_dispatch(device);
     85     disp->ext_dispatch.DevExt[8](device);
     86 }
     87 
     88 VKAPI_ATTR void VKAPI_CALL vkDevExt9(VkDevice device) {
     89     const struct loader_dev_dispatch_table *disp;
     90     disp = loader_get_dev_dispatch(device);
     91     disp->ext_dispatch.DevExt[9](device);
     92 }
     93 
     94 VKAPI_ATTR void VKAPI_CALL vkDevExt10(VkDevice device) {
     95     const struct loader_dev_dispatch_table *disp;
     96     disp = loader_get_dev_dispatch(device);
     97     disp->ext_dispatch.DevExt[10](device);
     98 }
     99 
    100 VKAPI_ATTR void VKAPI_CALL vkDevExt11(VkDevice device) {
    101     const struct loader_dev_dispatch_table *disp;
    102     disp = loader_get_dev_dispatch(device);
    103     disp->ext_dispatch.DevExt[11](device);
    104 }
    105 
    106 VKAPI_ATTR void VKAPI_CALL vkDevExt12(VkDevice device) {
    107     const struct loader_dev_dispatch_table *disp;
    108     disp = loader_get_dev_dispatch(device);
    109     disp->ext_dispatch.DevExt[12](device);
    110 }
    111 
    112 VKAPI_ATTR void VKAPI_CALL vkDevExt13(VkDevice device) {
    113     const struct loader_dev_dispatch_table *disp;
    114     disp = loader_get_dev_dispatch(device);
    115     disp->ext_dispatch.DevExt[13](device);
    116 }
    117 
    118 VKAPI_ATTR void VKAPI_CALL vkDevExt14(VkDevice device) {
    119     const struct loader_dev_dispatch_table *disp;
    120     disp = loader_get_dev_dispatch(device);
    121     disp->ext_dispatch.DevExt[14](device);
    122 }
    123 
    124 VKAPI_ATTR void VKAPI_CALL vkDevExt15(VkDevice device) {
    125     const struct loader_dev_dispatch_table *disp;
    126     disp = loader_get_dev_dispatch(device);
    127     disp->ext_dispatch.DevExt[15](device);
    128 }
    129 
    130 VKAPI_ATTR void VKAPI_CALL vkDevExt16(VkDevice device) {
    131     const struct loader_dev_dispatch_table *disp;
    132     disp = loader_get_dev_dispatch(device);
    133     disp->ext_dispatch.DevExt[16](device);
    134 }
    135 
    136 VKAPI_ATTR void VKAPI_CALL vkDevExt17(VkDevice device) {
    137     const struct loader_dev_dispatch_table *disp;
    138     disp = loader_get_dev_dispatch(device);
    139     disp->ext_dispatch.DevExt[17](device);
    140 }
    141 
    142 VKAPI_ATTR void VKAPI_CALL vkDevExt18(VkDevice device) {
    143     const struct loader_dev_dispatch_table *disp;
    144     disp = loader_get_dev_dispatch(device);
    145     disp->ext_dispatch.DevExt[18](device);
    146 }
    147 
    148 VKAPI_ATTR void VKAPI_CALL vkDevExt19(VkDevice device) {
    149     const struct loader_dev_dispatch_table *disp;
    150     disp = loader_get_dev_dispatch(device);
    151     disp->ext_dispatch.DevExt[19](device);
    152 }
    153 
    154 VKAPI_ATTR void VKAPI_CALL vkDevExt20(VkDevice device) {
    155     const struct loader_dev_dispatch_table *disp;
    156     disp = loader_get_dev_dispatch(device);
    157     disp->ext_dispatch.DevExt[20](device);
    158 }
    159 
    160 VKAPI_ATTR void VKAPI_CALL vkDevExt21(VkDevice device) {
    161     const struct loader_dev_dispatch_table *disp;
    162     disp = loader_get_dev_dispatch(device);
    163     disp->ext_dispatch.DevExt[21](device);
    164 }
    165 
    166 VKAPI_ATTR void VKAPI_CALL vkDevExt22(VkDevice device) {
    167     const struct loader_dev_dispatch_table *disp;
    168     disp = loader_get_dev_dispatch(device);
    169     disp->ext_dispatch.DevExt[22](device);
    170 }
    171 
    172 VKAPI_ATTR void VKAPI_CALL vkDevExt23(VkDevice device) {
    173     const struct loader_dev_dispatch_table *disp;
    174     disp = loader_get_dev_dispatch(device);
    175     disp->ext_dispatch.DevExt[23](device);
    176 }
    177 
    178 VKAPI_ATTR void VKAPI_CALL vkDevExt24(VkDevice device) {
    179     const struct loader_dev_dispatch_table *disp;
    180     disp = loader_get_dev_dispatch(device);
    181     disp->ext_dispatch.DevExt[24](device);
    182 }
    183 
    184 VKAPI_ATTR void VKAPI_CALL vkDevExt25(VkDevice device) {
    185     const struct loader_dev_dispatch_table *disp;
    186     disp = loader_get_dev_dispatch(device);
    187     disp->ext_dispatch.DevExt[25](device);
    188 }
    189 
    190 VKAPI_ATTR void VKAPI_CALL vkDevExt26(VkDevice device) {
    191     const struct loader_dev_dispatch_table *disp;
    192     disp = loader_get_dev_dispatch(device);
    193     disp->ext_dispatch.DevExt[26](device);
    194 }
    195 
    196 VKAPI_ATTR void VKAPI_CALL vkDevExt27(VkDevice device) {
    197     const struct loader_dev_dispatch_table *disp;
    198     disp = loader_get_dev_dispatch(device);
    199     disp->ext_dispatch.DevExt[27](device);
    200 }
    201 
    202 VKAPI_ATTR void VKAPI_CALL vkDevExt28(VkDevice device) {
    203     const struct loader_dev_dispatch_table *disp;
    204     disp = loader_get_dev_dispatch(device);
    205     disp->ext_dispatch.DevExt[28](device);
    206 }
    207 
    208 VKAPI_ATTR void VKAPI_CALL vkDevExt29(VkDevice device) {
    209     const struct loader_dev_dispatch_table *disp;
    210     disp = loader_get_dev_dispatch(device);
    211     disp->ext_dispatch.DevExt[29](device);
    212 }
    213 
    214 VKAPI_ATTR void VKAPI_CALL vkDevExt30(VkDevice device) {
    215     const struct loader_dev_dispatch_table *disp;
    216     disp = loader_get_dev_dispatch(device);
    217     disp->ext_dispatch.DevExt[30](device);
    218 }
    219 
    220 VKAPI_ATTR void VKAPI_CALL vkDevExt31(VkDevice device) {
    221     const struct loader_dev_dispatch_table *disp;
    222     disp = loader_get_dev_dispatch(device);
    223     disp->ext_dispatch.DevExt[31](device);
    224 }
    225 
    226 VKAPI_ATTR void VKAPI_CALL vkDevExt32(VkDevice device) {
    227     const struct loader_dev_dispatch_table *disp;
    228     disp = loader_get_dev_dispatch(device);
    229     disp->ext_dispatch.DevExt[32](device);
    230 }
    231 
    232 VKAPI_ATTR void VKAPI_CALL vkDevExt33(VkDevice device) {
    233     const struct loader_dev_dispatch_table *disp;
    234     disp = loader_get_dev_dispatch(device);
    235     disp->ext_dispatch.DevExt[33](device);
    236 }
    237 
    238 VKAPI_ATTR void VKAPI_CALL vkDevExt34(VkDevice device) {
    239     const struct loader_dev_dispatch_table *disp;
    240     disp = loader_get_dev_dispatch(device);
    241     disp->ext_dispatch.DevExt[34](device);
    242 }
    243 
    244 VKAPI_ATTR void VKAPI_CALL vkDevExt35(VkDevice device) {
    245     const struct loader_dev_dispatch_table *disp;
    246     disp = loader_get_dev_dispatch(device);
    247     disp->ext_dispatch.DevExt[35](device);
    248 }
    249 
    250 VKAPI_ATTR void VKAPI_CALL vkDevExt36(VkDevice device) {
    251     const struct loader_dev_dispatch_table *disp;
    252     disp = loader_get_dev_dispatch(device);
    253     disp->ext_dispatch.DevExt[36](device);
    254 }
    255 
    256 VKAPI_ATTR void VKAPI_CALL vkDevExt37(VkDevice device) {
    257     const struct loader_dev_dispatch_table *disp;
    258     disp = loader_get_dev_dispatch(device);
    259     disp->ext_dispatch.DevExt[37](device);
    260 }
    261 
    262 VKAPI_ATTR void VKAPI_CALL vkDevExt38(VkDevice device) {
    263     const struct loader_dev_dispatch_table *disp;
    264     disp = loader_get_dev_dispatch(device);
    265     disp->ext_dispatch.DevExt[38](device);
    266 }
    267 
    268 VKAPI_ATTR void VKAPI_CALL vkDevExt39(VkDevice device) {
    269     const struct loader_dev_dispatch_table *disp;
    270     disp = loader_get_dev_dispatch(device);
    271     disp->ext_dispatch.DevExt[39](device);
    272 }
    273 
    274 VKAPI_ATTR void VKAPI_CALL vkDevExt40(VkDevice device) {
    275     const struct loader_dev_dispatch_table *disp;
    276     disp = loader_get_dev_dispatch(device);
    277     disp->ext_dispatch.DevExt[40](device);
    278 }
    279 
    280 VKAPI_ATTR void VKAPI_CALL vkDevExt41(VkDevice device) {
    281     const struct loader_dev_dispatch_table *disp;
    282     disp = loader_get_dev_dispatch(device);
    283     disp->ext_dispatch.DevExt[41](device);
    284 }
    285 
    286 VKAPI_ATTR void VKAPI_CALL vkDevExt42(VkDevice device) {
    287     const struct loader_dev_dispatch_table *disp;
    288     disp = loader_get_dev_dispatch(device);
    289     disp->ext_dispatch.DevExt[42](device);
    290 }
    291 
    292 VKAPI_ATTR void VKAPI_CALL vkDevExt43(VkDevice device) {
    293     const struct loader_dev_dispatch_table *disp;
    294     disp = loader_get_dev_dispatch(device);
    295     disp->ext_dispatch.DevExt[43](device);
    296 }
    297 
    298 VKAPI_ATTR void VKAPI_CALL vkDevExt44(VkDevice device) {
    299     const struct loader_dev_dispatch_table *disp;
    300     disp = loader_get_dev_dispatch(device);
    301     disp->ext_dispatch.DevExt[44](device);
    302 }
    303 
    304 VKAPI_ATTR void VKAPI_CALL vkDevExt45(VkDevice device) {
    305     const struct loader_dev_dispatch_table *disp;
    306     disp = loader_get_dev_dispatch(device);
    307     disp->ext_dispatch.DevExt[45](device);
    308 }
    309 
    310 VKAPI_ATTR void VKAPI_CALL vkDevExt46(VkDevice device) {
    311     const struct loader_dev_dispatch_table *disp;
    312     disp = loader_get_dev_dispatch(device);
    313     disp->ext_dispatch.DevExt[46](device);
    314 }
    315 
    316 VKAPI_ATTR void VKAPI_CALL vkDevExt47(VkDevice device) {
    317     const struct loader_dev_dispatch_table *disp;
    318     disp = loader_get_dev_dispatch(device);
    319     disp->ext_dispatch.DevExt[47](device);
    320 }
    321 
    322 VKAPI_ATTR void VKAPI_CALL vkDevExt48(VkDevice device) {
    323     const struct loader_dev_dispatch_table *disp;
    324     disp = loader_get_dev_dispatch(device);
    325     disp->ext_dispatch.DevExt[48](device);
    326 }
    327 
    328 VKAPI_ATTR void VKAPI_CALL vkDevExt49(VkDevice device) {
    329     const struct loader_dev_dispatch_table *disp;
    330     disp = loader_get_dev_dispatch(device);
    331     disp->ext_dispatch.DevExt[49](device);
    332 }
    333 
    334 VKAPI_ATTR void VKAPI_CALL vkDevExt50(VkDevice device) {
    335     const struct loader_dev_dispatch_table *disp;
    336     disp = loader_get_dev_dispatch(device);
    337     disp->ext_dispatch.DevExt[50](device);
    338 }
    339 
    340 VKAPI_ATTR void VKAPI_CALL vkDevExt51(VkDevice device) {
    341     const struct loader_dev_dispatch_table *disp;
    342     disp = loader_get_dev_dispatch(device);
    343     disp->ext_dispatch.DevExt[51](device);
    344 }
    345 
    346 VKAPI_ATTR void VKAPI_CALL vkDevExt52(VkDevice device) {
    347     const struct loader_dev_dispatch_table *disp;
    348     disp = loader_get_dev_dispatch(device);
    349     disp->ext_dispatch.DevExt[52](device);
    350 }
    351 
    352 VKAPI_ATTR void VKAPI_CALL vkDevExt53(VkDevice device) {
    353     const struct loader_dev_dispatch_table *disp;
    354     disp = loader_get_dev_dispatch(device);
    355     disp->ext_dispatch.DevExt[53](device);
    356 }
    357 
    358 VKAPI_ATTR void VKAPI_CALL vkDevExt54(VkDevice device) {
    359     const struct loader_dev_dispatch_table *disp;
    360     disp = loader_get_dev_dispatch(device);
    361     disp->ext_dispatch.DevExt[54](device);
    362 }
    363 
    364 VKAPI_ATTR void VKAPI_CALL vkDevExt55(VkDevice device) {
    365     const struct loader_dev_dispatch_table *disp;
    366     disp = loader_get_dev_dispatch(device);
    367     disp->ext_dispatch.DevExt[55](device);
    368 }
    369 
    370 VKAPI_ATTR void VKAPI_CALL vkDevExt56(VkDevice device) {
    371     const struct loader_dev_dispatch_table *disp;
    372     disp = loader_get_dev_dispatch(device);
    373     disp->ext_dispatch.DevExt[56](device);
    374 }
    375 
    376 VKAPI_ATTR void VKAPI_CALL vkDevExt57(VkDevice device) {
    377     const struct loader_dev_dispatch_table *disp;
    378     disp = loader_get_dev_dispatch(device);
    379     disp->ext_dispatch.DevExt[57](device);
    380 }
    381 
    382 VKAPI_ATTR void VKAPI_CALL vkDevExt58(VkDevice device) {
    383     const struct loader_dev_dispatch_table *disp;
    384     disp = loader_get_dev_dispatch(device);
    385     disp->ext_dispatch.DevExt[58](device);
    386 }
    387 
    388 VKAPI_ATTR void VKAPI_CALL vkDevExt59(VkDevice device) {
    389     const struct loader_dev_dispatch_table *disp;
    390     disp = loader_get_dev_dispatch(device);
    391     disp->ext_dispatch.DevExt[59](device);
    392 }
    393 
    394 VKAPI_ATTR void VKAPI_CALL vkDevExt60(VkDevice device) {
    395     const struct loader_dev_dispatch_table *disp;
    396     disp = loader_get_dev_dispatch(device);
    397     disp->ext_dispatch.DevExt[60](device);
    398 }
    399 
    400 VKAPI_ATTR void VKAPI_CALL vkDevExt61(VkDevice device) {
    401     const struct loader_dev_dispatch_table *disp;
    402     disp = loader_get_dev_dispatch(device);
    403     disp->ext_dispatch.DevExt[61](device);
    404 }
    405 
    406 VKAPI_ATTR void VKAPI_CALL vkDevExt62(VkDevice device) {
    407     const struct loader_dev_dispatch_table *disp;
    408     disp = loader_get_dev_dispatch(device);
    409     disp->ext_dispatch.DevExt[62](device);
    410 }
    411 
    412 VKAPI_ATTR void VKAPI_CALL vkDevExt63(VkDevice device) {
    413     const struct loader_dev_dispatch_table *disp;
    414     disp = loader_get_dev_dispatch(device);
    415     disp->ext_dispatch.DevExt[63](device);
    416 }
    417 
    418 VKAPI_ATTR void VKAPI_CALL vkDevExt64(VkDevice device) {
    419     const struct loader_dev_dispatch_table *disp;
    420     disp = loader_get_dev_dispatch(device);
    421     disp->ext_dispatch.DevExt[64](device);
    422 }
    423 
    424 VKAPI_ATTR void VKAPI_CALL vkDevExt65(VkDevice device) {
    425     const struct loader_dev_dispatch_table *disp;
    426     disp = loader_get_dev_dispatch(device);
    427     disp->ext_dispatch.DevExt[65](device);
    428 }
    429 
    430 VKAPI_ATTR void VKAPI_CALL vkDevExt66(VkDevice device) {
    431     const struct loader_dev_dispatch_table *disp;
    432     disp = loader_get_dev_dispatch(device);
    433     disp->ext_dispatch.DevExt[66](device);
    434 }
    435 
    436 VKAPI_ATTR void VKAPI_CALL vkDevExt67(VkDevice device) {
    437     const struct loader_dev_dispatch_table *disp;
    438     disp = loader_get_dev_dispatch(device);
    439     disp->ext_dispatch.DevExt[67](device);
    440 }
    441 
    442 VKAPI_ATTR void VKAPI_CALL vkDevExt68(VkDevice device) {
    443     const struct loader_dev_dispatch_table *disp;
    444     disp = loader_get_dev_dispatch(device);
    445     disp->ext_dispatch.DevExt[68](device);
    446 }
    447 
    448 VKAPI_ATTR void VKAPI_CALL vkDevExt69(VkDevice device) {
    449     const struct loader_dev_dispatch_table *disp;
    450     disp = loader_get_dev_dispatch(device);
    451     disp->ext_dispatch.DevExt[69](device);
    452 }
    453 
    454 VKAPI_ATTR void VKAPI_CALL vkDevExt70(VkDevice device) {
    455     const struct loader_dev_dispatch_table *disp;
    456     disp = loader_get_dev_dispatch(device);
    457     disp->ext_dispatch.DevExt[70](device);
    458 }
    459 
    460 VKAPI_ATTR void VKAPI_CALL vkDevExt71(VkDevice device) {
    461     const struct loader_dev_dispatch_table *disp;
    462     disp = loader_get_dev_dispatch(device);
    463     disp->ext_dispatch.DevExt[71](device);
    464 }
    465 
    466 VKAPI_ATTR void VKAPI_CALL vkDevExt72(VkDevice device) {
    467     const struct loader_dev_dispatch_table *disp;
    468     disp = loader_get_dev_dispatch(device);
    469     disp->ext_dispatch.DevExt[72](device);
    470 }
    471 
    472 VKAPI_ATTR void VKAPI_CALL vkDevExt73(VkDevice device) {
    473     const struct loader_dev_dispatch_table *disp;
    474     disp = loader_get_dev_dispatch(device);
    475     disp->ext_dispatch.DevExt[73](device);
    476 }
    477 
    478 VKAPI_ATTR void VKAPI_CALL vkDevExt74(VkDevice device) {
    479     const struct loader_dev_dispatch_table *disp;
    480     disp = loader_get_dev_dispatch(device);
    481     disp->ext_dispatch.DevExt[74](device);
    482 }
    483 
    484 VKAPI_ATTR void VKAPI_CALL vkDevExt75(VkDevice device) {
    485     const struct loader_dev_dispatch_table *disp;
    486     disp = loader_get_dev_dispatch(device);
    487     disp->ext_dispatch.DevExt[75](device);
    488 }
    489 
    490 VKAPI_ATTR void VKAPI_CALL vkDevExt76(VkDevice device) {
    491     const struct loader_dev_dispatch_table *disp;
    492     disp = loader_get_dev_dispatch(device);
    493     disp->ext_dispatch.DevExt[76](device);
    494 }
    495 
    496 VKAPI_ATTR void VKAPI_CALL vkDevExt77(VkDevice device) {
    497     const struct loader_dev_dispatch_table *disp;
    498     disp = loader_get_dev_dispatch(device);
    499     disp->ext_dispatch.DevExt[77](device);
    500 }
    501 
    502 VKAPI_ATTR void VKAPI_CALL vkDevExt78(VkDevice device) {
    503     const struct loader_dev_dispatch_table *disp;
    504     disp = loader_get_dev_dispatch(device);
    505     disp->ext_dispatch.DevExt[78](device);
    506 }
    507 
    508 VKAPI_ATTR void VKAPI_CALL vkDevExt79(VkDevice device) {
    509     const struct loader_dev_dispatch_table *disp;
    510     disp = loader_get_dev_dispatch(device);
    511     disp->ext_dispatch.DevExt[79](device);
    512 }
    513 
    514 VKAPI_ATTR void VKAPI_CALL vkDevExt80(VkDevice device) {
    515     const struct loader_dev_dispatch_table *disp;
    516     disp = loader_get_dev_dispatch(device);
    517     disp->ext_dispatch.DevExt[80](device);
    518 }
    519 
    520 VKAPI_ATTR void VKAPI_CALL vkDevExt81(VkDevice device) {
    521     const struct loader_dev_dispatch_table *disp;
    522     disp = loader_get_dev_dispatch(device);
    523     disp->ext_dispatch.DevExt[81](device);
    524 }
    525 
    526 VKAPI_ATTR void VKAPI_CALL vkDevExt82(VkDevice device) {
    527     const struct loader_dev_dispatch_table *disp;
    528     disp = loader_get_dev_dispatch(device);
    529     disp->ext_dispatch.DevExt[82](device);
    530 }
    531 
    532 VKAPI_ATTR void VKAPI_CALL vkDevExt83(VkDevice device) {
    533     const struct loader_dev_dispatch_table *disp;
    534     disp = loader_get_dev_dispatch(device);
    535     disp->ext_dispatch.DevExt[83](device);
    536 }
    537 
    538 VKAPI_ATTR void VKAPI_CALL vkDevExt84(VkDevice device) {
    539     const struct loader_dev_dispatch_table *disp;
    540     disp = loader_get_dev_dispatch(device);
    541     disp->ext_dispatch.DevExt[84](device);
    542 }
    543 
    544 VKAPI_ATTR void VKAPI_CALL vkDevExt85(VkDevice device) {
    545     const struct loader_dev_dispatch_table *disp;
    546     disp = loader_get_dev_dispatch(device);
    547     disp->ext_dispatch.DevExt[85](device);
    548 }
    549 
    550 VKAPI_ATTR void VKAPI_CALL vkDevExt86(VkDevice device) {
    551     const struct loader_dev_dispatch_table *disp;
    552     disp = loader_get_dev_dispatch(device);
    553     disp->ext_dispatch.DevExt[86](device);
    554 }
    555 
    556 VKAPI_ATTR void VKAPI_CALL vkDevExt87(VkDevice device) {
    557     const struct loader_dev_dispatch_table *disp;
    558     disp = loader_get_dev_dispatch(device);
    559     disp->ext_dispatch.DevExt[87](device);
    560 }
    561 
    562 VKAPI_ATTR void VKAPI_CALL vkDevExt88(VkDevice device) {
    563     const struct loader_dev_dispatch_table *disp;
    564     disp = loader_get_dev_dispatch(device);
    565     disp->ext_dispatch.DevExt[88](device);
    566 }
    567 
    568 VKAPI_ATTR void VKAPI_CALL vkDevExt89(VkDevice device) {
    569     const struct loader_dev_dispatch_table *disp;
    570     disp = loader_get_dev_dispatch(device);
    571     disp->ext_dispatch.DevExt[89](device);
    572 }
    573 
    574 VKAPI_ATTR void VKAPI_CALL vkDevExt90(VkDevice device) {
    575     const struct loader_dev_dispatch_table *disp;
    576     disp = loader_get_dev_dispatch(device);
    577     disp->ext_dispatch.DevExt[90](device);
    578 }
    579 
    580 VKAPI_ATTR void VKAPI_CALL vkDevExt91(VkDevice device) {
    581     const struct loader_dev_dispatch_table *disp;
    582     disp = loader_get_dev_dispatch(device);
    583     disp->ext_dispatch.DevExt[91](device);
    584 }
    585 
    586 VKAPI_ATTR void VKAPI_CALL vkDevExt92(VkDevice device) {
    587     const struct loader_dev_dispatch_table *disp;
    588     disp = loader_get_dev_dispatch(device);
    589     disp->ext_dispatch.DevExt[92](device);
    590 }
    591 
    592 VKAPI_ATTR void VKAPI_CALL vkDevExt93(VkDevice device) {
    593     const struct loader_dev_dispatch_table *disp;
    594     disp = loader_get_dev_dispatch(device);
    595     disp->ext_dispatch.DevExt[93](device);
    596 }
    597 
    598 VKAPI_ATTR void VKAPI_CALL vkDevExt94(VkDevice device) {
    599     const struct loader_dev_dispatch_table *disp;
    600     disp = loader_get_dev_dispatch(device);
    601     disp->ext_dispatch.DevExt[94](device);
    602 }
    603 
    604 VKAPI_ATTR void VKAPI_CALL vkDevExt95(VkDevice device) {
    605     const struct loader_dev_dispatch_table *disp;
    606     disp = loader_get_dev_dispatch(device);
    607     disp->ext_dispatch.DevExt[95](device);
    608 }
    609 
    610 VKAPI_ATTR void VKAPI_CALL vkDevExt96(VkDevice device) {
    611     const struct loader_dev_dispatch_table *disp;
    612     disp = loader_get_dev_dispatch(device);
    613     disp->ext_dispatch.DevExt[96](device);
    614 }
    615 
    616 VKAPI_ATTR void VKAPI_CALL vkDevExt97(VkDevice device) {
    617     const struct loader_dev_dispatch_table *disp;
    618     disp = loader_get_dev_dispatch(device);
    619     disp->ext_dispatch.DevExt[97](device);
    620 }
    621 
    622 VKAPI_ATTR void VKAPI_CALL vkDevExt98(VkDevice device) {
    623     const struct loader_dev_dispatch_table *disp;
    624     disp = loader_get_dev_dispatch(device);
    625     disp->ext_dispatch.DevExt[98](device);
    626 }
    627 
    628 VKAPI_ATTR void VKAPI_CALL vkDevExt99(VkDevice device) {
    629     const struct loader_dev_dispatch_table *disp;
    630     disp = loader_get_dev_dispatch(device);
    631     disp->ext_dispatch.DevExt[99](device);
    632 }
    633 
    634 VKAPI_ATTR void VKAPI_CALL vkDevExt100(VkDevice device) {
    635     const struct loader_dev_dispatch_table *disp;
    636     disp = loader_get_dev_dispatch(device);
    637     disp->ext_dispatch.DevExt[100](device);
    638 }
    639 
    640 VKAPI_ATTR void VKAPI_CALL vkDevExt101(VkDevice device) {
    641     const struct loader_dev_dispatch_table *disp;
    642     disp = loader_get_dev_dispatch(device);
    643     disp->ext_dispatch.DevExt[101](device);
    644 }
    645 
    646 VKAPI_ATTR void VKAPI_CALL vkDevExt102(VkDevice device) {
    647     const struct loader_dev_dispatch_table *disp;
    648     disp = loader_get_dev_dispatch(device);
    649     disp->ext_dispatch.DevExt[102](device);
    650 }
    651 
    652 VKAPI_ATTR void VKAPI_CALL vkDevExt103(VkDevice device) {
    653     const struct loader_dev_dispatch_table *disp;
    654     disp = loader_get_dev_dispatch(device);
    655     disp->ext_dispatch.DevExt[103](device);
    656 }
    657 
    658 VKAPI_ATTR void VKAPI_CALL vkDevExt104(VkDevice device) {
    659     const struct loader_dev_dispatch_table *disp;
    660     disp = loader_get_dev_dispatch(device);
    661     disp->ext_dispatch.DevExt[104](device);
    662 }
    663 
    664 VKAPI_ATTR void VKAPI_CALL vkDevExt105(VkDevice device) {
    665     const struct loader_dev_dispatch_table *disp;
    666     disp = loader_get_dev_dispatch(device);
    667     disp->ext_dispatch.DevExt[105](device);
    668 }
    669 
    670 VKAPI_ATTR void VKAPI_CALL vkDevExt106(VkDevice device) {
    671     const struct loader_dev_dispatch_table *disp;
    672     disp = loader_get_dev_dispatch(device);
    673     disp->ext_dispatch.DevExt[106](device);
    674 }
    675 
    676 VKAPI_ATTR void VKAPI_CALL vkDevExt107(VkDevice device) {
    677     const struct loader_dev_dispatch_table *disp;
    678     disp = loader_get_dev_dispatch(device);
    679     disp->ext_dispatch.DevExt[107](device);
    680 }
    681 
    682 VKAPI_ATTR void VKAPI_CALL vkDevExt108(VkDevice device) {
    683     const struct loader_dev_dispatch_table *disp;
    684     disp = loader_get_dev_dispatch(device);
    685     disp->ext_dispatch.DevExt[108](device);
    686 }
    687 
    688 VKAPI_ATTR void VKAPI_CALL vkDevExt109(VkDevice device) {
    689     const struct loader_dev_dispatch_table *disp;
    690     disp = loader_get_dev_dispatch(device);
    691     disp->ext_dispatch.DevExt[109](device);
    692 }
    693 
    694 VKAPI_ATTR void VKAPI_CALL vkDevExt110(VkDevice device) {
    695     const struct loader_dev_dispatch_table *disp;
    696     disp = loader_get_dev_dispatch(device);
    697     disp->ext_dispatch.DevExt[110](device);
    698 }
    699 
    700 VKAPI_ATTR void VKAPI_CALL vkDevExt111(VkDevice device) {
    701     const struct loader_dev_dispatch_table *disp;
    702     disp = loader_get_dev_dispatch(device);
    703     disp->ext_dispatch.DevExt[111](device);
    704 }
    705 
    706 VKAPI_ATTR void VKAPI_CALL vkDevExt112(VkDevice device) {
    707     const struct loader_dev_dispatch_table *disp;
    708     disp = loader_get_dev_dispatch(device);
    709     disp->ext_dispatch.DevExt[112](device);
    710 }
    711 
    712 VKAPI_ATTR void VKAPI_CALL vkDevExt113(VkDevice device) {
    713     const struct loader_dev_dispatch_table *disp;
    714     disp = loader_get_dev_dispatch(device);
    715     disp->ext_dispatch.DevExt[113](device);
    716 }
    717 
    718 VKAPI_ATTR void VKAPI_CALL vkDevExt114(VkDevice device) {
    719     const struct loader_dev_dispatch_table *disp;
    720     disp = loader_get_dev_dispatch(device);
    721     disp->ext_dispatch.DevExt[114](device);
    722 }
    723 
    724 VKAPI_ATTR void VKAPI_CALL vkDevExt115(VkDevice device) {
    725     const struct loader_dev_dispatch_table *disp;
    726     disp = loader_get_dev_dispatch(device);
    727     disp->ext_dispatch.DevExt[115](device);
    728 }
    729 
    730 VKAPI_ATTR void VKAPI_CALL vkDevExt116(VkDevice device) {
    731     const struct loader_dev_dispatch_table *disp;
    732     disp = loader_get_dev_dispatch(device);
    733     disp->ext_dispatch.DevExt[116](device);
    734 }
    735 
    736 VKAPI_ATTR void VKAPI_CALL vkDevExt117(VkDevice device) {
    737     const struct loader_dev_dispatch_table *disp;
    738     disp = loader_get_dev_dispatch(device);
    739     disp->ext_dispatch.DevExt[117](device);
    740 }
    741 
    742 VKAPI_ATTR void VKAPI_CALL vkDevExt118(VkDevice device) {
    743     const struct loader_dev_dispatch_table *disp;
    744     disp = loader_get_dev_dispatch(device);
    745     disp->ext_dispatch.DevExt[118](device);
    746 }
    747 
    748 VKAPI_ATTR void VKAPI_CALL vkDevExt119(VkDevice device) {
    749     const struct loader_dev_dispatch_table *disp;
    750     disp = loader_get_dev_dispatch(device);
    751     disp->ext_dispatch.DevExt[119](device);
    752 }
    753 
    754 VKAPI_ATTR void VKAPI_CALL vkDevExt120(VkDevice device) {
    755     const struct loader_dev_dispatch_table *disp;
    756     disp = loader_get_dev_dispatch(device);
    757     disp->ext_dispatch.DevExt[120](device);
    758 }
    759 
    760 VKAPI_ATTR void VKAPI_CALL vkDevExt121(VkDevice device) {
    761     const struct loader_dev_dispatch_table *disp;
    762     disp = loader_get_dev_dispatch(device);
    763     disp->ext_dispatch.DevExt[121](device);
    764 }
    765 
    766 VKAPI_ATTR void VKAPI_CALL vkDevExt122(VkDevice device) {
    767     const struct loader_dev_dispatch_table *disp;
    768     disp = loader_get_dev_dispatch(device);
    769     disp->ext_dispatch.DevExt[122](device);
    770 }
    771 
    772 VKAPI_ATTR void VKAPI_CALL vkDevExt123(VkDevice device) {
    773     const struct loader_dev_dispatch_table *disp;
    774     disp = loader_get_dev_dispatch(device);
    775     disp->ext_dispatch.DevExt[123](device);
    776 }
    777 
    778 VKAPI_ATTR void VKAPI_CALL vkDevExt124(VkDevice device) {
    779     const struct loader_dev_dispatch_table *disp;
    780     disp = loader_get_dev_dispatch(device);
    781     disp->ext_dispatch.DevExt[124](device);
    782 }
    783 
    784 VKAPI_ATTR void VKAPI_CALL vkDevExt125(VkDevice device) {
    785     const struct loader_dev_dispatch_table *disp;
    786     disp = loader_get_dev_dispatch(device);
    787     disp->ext_dispatch.DevExt[125](device);
    788 }
    789 
    790 VKAPI_ATTR void VKAPI_CALL vkDevExt126(VkDevice device) {
    791     const struct loader_dev_dispatch_table *disp;
    792     disp = loader_get_dev_dispatch(device);
    793     disp->ext_dispatch.DevExt[126](device);
    794 }
    795 
    796 VKAPI_ATTR void VKAPI_CALL vkDevExt127(VkDevice device) {
    797     const struct loader_dev_dispatch_table *disp;
    798     disp = loader_get_dev_dispatch(device);
    799     disp->ext_dispatch.DevExt[127](device);
    800 }
    801 
    802 VKAPI_ATTR void VKAPI_CALL vkDevExt128(VkDevice device) {
    803     const struct loader_dev_dispatch_table *disp;
    804     disp = loader_get_dev_dispatch(device);
    805     disp->ext_dispatch.DevExt[128](device);
    806 }
    807 
    808 VKAPI_ATTR void VKAPI_CALL vkDevExt129(VkDevice device) {
    809     const struct loader_dev_dispatch_table *disp;
    810     disp = loader_get_dev_dispatch(device);
    811     disp->ext_dispatch.DevExt[129](device);
    812 }
    813 
    814 VKAPI_ATTR void VKAPI_CALL vkDevExt130(VkDevice device) {
    815     const struct loader_dev_dispatch_table *disp;
    816     disp = loader_get_dev_dispatch(device);
    817     disp->ext_dispatch.DevExt[130](device);
    818 }
    819 
    820 VKAPI_ATTR void VKAPI_CALL vkDevExt131(VkDevice device) {
    821     const struct loader_dev_dispatch_table *disp;
    822     disp = loader_get_dev_dispatch(device);
    823     disp->ext_dispatch.DevExt[131](device);
    824 }
    825 
    826 VKAPI_ATTR void VKAPI_CALL vkDevExt132(VkDevice device) {
    827     const struct loader_dev_dispatch_table *disp;
    828     disp = loader_get_dev_dispatch(device);
    829     disp->ext_dispatch.DevExt[132](device);
    830 }
    831 
    832 VKAPI_ATTR void VKAPI_CALL vkDevExt133(VkDevice device) {
    833     const struct loader_dev_dispatch_table *disp;
    834     disp = loader_get_dev_dispatch(device);
    835     disp->ext_dispatch.DevExt[133](device);
    836 }
    837 
    838 VKAPI_ATTR void VKAPI_CALL vkDevExt134(VkDevice device) {
    839     const struct loader_dev_dispatch_table *disp;
    840     disp = loader_get_dev_dispatch(device);
    841     disp->ext_dispatch.DevExt[134](device);
    842 }
    843 
    844 VKAPI_ATTR void VKAPI_CALL vkDevExt135(VkDevice device) {
    845     const struct loader_dev_dispatch_table *disp;
    846     disp = loader_get_dev_dispatch(device);
    847     disp->ext_dispatch.DevExt[135](device);
    848 }
    849 
    850 VKAPI_ATTR void VKAPI_CALL vkDevExt136(VkDevice device) {
    851     const struct loader_dev_dispatch_table *disp;
    852     disp = loader_get_dev_dispatch(device);
    853     disp->ext_dispatch.DevExt[136](device);
    854 }
    855 
    856 VKAPI_ATTR void VKAPI_CALL vkDevExt137(VkDevice device) {
    857     const struct loader_dev_dispatch_table *disp;
    858     disp = loader_get_dev_dispatch(device);
    859     disp->ext_dispatch.DevExt[137](device);
    860 }
    861 
    862 VKAPI_ATTR void VKAPI_CALL vkDevExt138(VkDevice device) {
    863     const struct loader_dev_dispatch_table *disp;
    864     disp = loader_get_dev_dispatch(device);
    865     disp->ext_dispatch.DevExt[138](device);
    866 }
    867 
    868 VKAPI_ATTR void VKAPI_CALL vkDevExt139(VkDevice device) {
    869     const struct loader_dev_dispatch_table *disp;
    870     disp = loader_get_dev_dispatch(device);
    871     disp->ext_dispatch.DevExt[139](device);
    872 }
    873 
    874 VKAPI_ATTR void VKAPI_CALL vkDevExt140(VkDevice device) {
    875     const struct loader_dev_dispatch_table *disp;
    876     disp = loader_get_dev_dispatch(device);
    877     disp->ext_dispatch.DevExt[140](device);
    878 }
    879 
    880 VKAPI_ATTR void VKAPI_CALL vkDevExt141(VkDevice device) {
    881     const struct loader_dev_dispatch_table *disp;
    882     disp = loader_get_dev_dispatch(device);
    883     disp->ext_dispatch.DevExt[141](device);
    884 }
    885 
    886 VKAPI_ATTR void VKAPI_CALL vkDevExt142(VkDevice device) {
    887     const struct loader_dev_dispatch_table *disp;
    888     disp = loader_get_dev_dispatch(device);
    889     disp->ext_dispatch.DevExt[142](device);
    890 }
    891 
    892 VKAPI_ATTR void VKAPI_CALL vkDevExt143(VkDevice device) {
    893     const struct loader_dev_dispatch_table *disp;
    894     disp = loader_get_dev_dispatch(device);
    895     disp->ext_dispatch.DevExt[143](device);
    896 }
    897 
    898 VKAPI_ATTR void VKAPI_CALL vkDevExt144(VkDevice device) {
    899     const struct loader_dev_dispatch_table *disp;
    900     disp = loader_get_dev_dispatch(device);
    901     disp->ext_dispatch.DevExt[144](device);
    902 }
    903 
    904 VKAPI_ATTR void VKAPI_CALL vkDevExt145(VkDevice device) {
    905     const struct loader_dev_dispatch_table *disp;
    906     disp = loader_get_dev_dispatch(device);
    907     disp->ext_dispatch.DevExt[145](device);
    908 }
    909 
    910 VKAPI_ATTR void VKAPI_CALL vkDevExt146(VkDevice device) {
    911     const struct loader_dev_dispatch_table *disp;
    912     disp = loader_get_dev_dispatch(device);
    913     disp->ext_dispatch.DevExt[146](device);
    914 }
    915 
    916 VKAPI_ATTR void VKAPI_CALL vkDevExt147(VkDevice device) {
    917     const struct loader_dev_dispatch_table *disp;
    918     disp = loader_get_dev_dispatch(device);
    919     disp->ext_dispatch.DevExt[147](device);
    920 }
    921 
    922 VKAPI_ATTR void VKAPI_CALL vkDevExt148(VkDevice device) {
    923     const struct loader_dev_dispatch_table *disp;
    924     disp = loader_get_dev_dispatch(device);
    925     disp->ext_dispatch.DevExt[148](device);
    926 }
    927 
    928 VKAPI_ATTR void VKAPI_CALL vkDevExt149(VkDevice device) {
    929     const struct loader_dev_dispatch_table *disp;
    930     disp = loader_get_dev_dispatch(device);
    931     disp->ext_dispatch.DevExt[149](device);
    932 }
    933 
    934 VKAPI_ATTR void VKAPI_CALL vkDevExt150(VkDevice device) {
    935     const struct loader_dev_dispatch_table *disp;
    936     disp = loader_get_dev_dispatch(device);
    937     disp->ext_dispatch.DevExt[150](device);
    938 }
    939 
    940 VKAPI_ATTR void VKAPI_CALL vkDevExt151(VkDevice device) {
    941     const struct loader_dev_dispatch_table *disp;
    942     disp = loader_get_dev_dispatch(device);
    943     disp->ext_dispatch.DevExt[151](device);
    944 }
    945 
    946 VKAPI_ATTR void VKAPI_CALL vkDevExt152(VkDevice device) {
    947     const struct loader_dev_dispatch_table *disp;
    948     disp = loader_get_dev_dispatch(device);
    949     disp->ext_dispatch.DevExt[152](device);
    950 }
    951 
    952 VKAPI_ATTR void VKAPI_CALL vkDevExt153(VkDevice device) {
    953     const struct loader_dev_dispatch_table *disp;
    954     disp = loader_get_dev_dispatch(device);
    955     disp->ext_dispatch.DevExt[153](device);
    956 }
    957 
    958 VKAPI_ATTR void VKAPI_CALL vkDevExt154(VkDevice device) {
    959     const struct loader_dev_dispatch_table *disp;
    960     disp = loader_get_dev_dispatch(device);
    961     disp->ext_dispatch.DevExt[154](device);
    962 }
    963 
    964 VKAPI_ATTR void VKAPI_CALL vkDevExt155(VkDevice device) {
    965     const struct loader_dev_dispatch_table *disp;
    966     disp = loader_get_dev_dispatch(device);
    967     disp->ext_dispatch.DevExt[155](device);
    968 }
    969 
    970 VKAPI_ATTR void VKAPI_CALL vkDevExt156(VkDevice device) {
    971     const struct loader_dev_dispatch_table *disp;
    972     disp = loader_get_dev_dispatch(device);
    973     disp->ext_dispatch.DevExt[156](device);
    974 }
    975 
    976 VKAPI_ATTR void VKAPI_CALL vkDevExt157(VkDevice device) {
    977     const struct loader_dev_dispatch_table *disp;
    978     disp = loader_get_dev_dispatch(device);
    979     disp->ext_dispatch.DevExt[157](device);
    980 }
    981 
    982 VKAPI_ATTR void VKAPI_CALL vkDevExt158(VkDevice device) {
    983     const struct loader_dev_dispatch_table *disp;
    984     disp = loader_get_dev_dispatch(device);
    985     disp->ext_dispatch.DevExt[158](device);
    986 }
    987 
    988 VKAPI_ATTR void VKAPI_CALL vkDevExt159(VkDevice device) {
    989     const struct loader_dev_dispatch_table *disp;
    990     disp = loader_get_dev_dispatch(device);
    991     disp->ext_dispatch.DevExt[159](device);
    992 }
    993 
    994 VKAPI_ATTR void VKAPI_CALL vkDevExt160(VkDevice device) {
    995     const struct loader_dev_dispatch_table *disp;
    996     disp = loader_get_dev_dispatch(device);
    997     disp->ext_dispatch.DevExt[160](device);
    998 }
    999 
   1000 VKAPI_ATTR void VKAPI_CALL vkDevExt161(VkDevice device) {
   1001     const struct loader_dev_dispatch_table *disp;
   1002     disp = loader_get_dev_dispatch(device);
   1003     disp->ext_dispatch.DevExt[161](device);
   1004 }
   1005 
   1006 VKAPI_ATTR void VKAPI_CALL vkDevExt162(VkDevice device) {
   1007     const struct loader_dev_dispatch_table *disp;
   1008     disp = loader_get_dev_dispatch(device);
   1009     disp->ext_dispatch.DevExt[162](device);
   1010 }
   1011 
   1012 VKAPI_ATTR void VKAPI_CALL vkDevExt163(VkDevice device) {
   1013     const struct loader_dev_dispatch_table *disp;
   1014     disp = loader_get_dev_dispatch(device);
   1015     disp->ext_dispatch.DevExt[163](device);
   1016 }
   1017 
   1018 VKAPI_ATTR void VKAPI_CALL vkDevExt164(VkDevice device) {
   1019     const struct loader_dev_dispatch_table *disp;
   1020     disp = loader_get_dev_dispatch(device);
   1021     disp->ext_dispatch.DevExt[164](device);
   1022 }
   1023 
   1024 VKAPI_ATTR void VKAPI_CALL vkDevExt165(VkDevice device) {
   1025     const struct loader_dev_dispatch_table *disp;
   1026     disp = loader_get_dev_dispatch(device);
   1027     disp->ext_dispatch.DevExt[165](device);
   1028 }
   1029 
   1030 VKAPI_ATTR void VKAPI_CALL vkDevExt166(VkDevice device) {
   1031     const struct loader_dev_dispatch_table *disp;
   1032     disp = loader_get_dev_dispatch(device);
   1033     disp->ext_dispatch.DevExt[166](device);
   1034 }
   1035 
   1036 VKAPI_ATTR void VKAPI_CALL vkDevExt167(VkDevice device) {
   1037     const struct loader_dev_dispatch_table *disp;
   1038     disp = loader_get_dev_dispatch(device);
   1039     disp->ext_dispatch.DevExt[167](device);
   1040 }
   1041 
   1042 VKAPI_ATTR void VKAPI_CALL vkDevExt168(VkDevice device) {
   1043     const struct loader_dev_dispatch_table *disp;
   1044     disp = loader_get_dev_dispatch(device);
   1045     disp->ext_dispatch.DevExt[168](device);
   1046 }
   1047 
   1048 VKAPI_ATTR void VKAPI_CALL vkDevExt169(VkDevice device) {
   1049     const struct loader_dev_dispatch_table *disp;
   1050     disp = loader_get_dev_dispatch(device);
   1051     disp->ext_dispatch.DevExt[169](device);
   1052 }
   1053 
   1054 VKAPI_ATTR void VKAPI_CALL vkDevExt170(VkDevice device) {
   1055     const struct loader_dev_dispatch_table *disp;
   1056     disp = loader_get_dev_dispatch(device);
   1057     disp->ext_dispatch.DevExt[170](device);
   1058 }
   1059 
   1060 VKAPI_ATTR void VKAPI_CALL vkDevExt171(VkDevice device) {
   1061     const struct loader_dev_dispatch_table *disp;
   1062     disp = loader_get_dev_dispatch(device);
   1063     disp->ext_dispatch.DevExt[171](device);
   1064 }
   1065 
   1066 VKAPI_ATTR void VKAPI_CALL vkDevExt172(VkDevice device) {
   1067     const struct loader_dev_dispatch_table *disp;
   1068     disp = loader_get_dev_dispatch(device);
   1069     disp->ext_dispatch.DevExt[172](device);
   1070 }
   1071 
   1072 VKAPI_ATTR void VKAPI_CALL vkDevExt173(VkDevice device) {
   1073     const struct loader_dev_dispatch_table *disp;
   1074     disp = loader_get_dev_dispatch(device);
   1075     disp->ext_dispatch.DevExt[173](device);
   1076 }
   1077 
   1078 VKAPI_ATTR void VKAPI_CALL vkDevExt174(VkDevice device) {
   1079     const struct loader_dev_dispatch_table *disp;
   1080     disp = loader_get_dev_dispatch(device);
   1081     disp->ext_dispatch.DevExt[174](device);
   1082 }
   1083 
   1084 VKAPI_ATTR void VKAPI_CALL vkDevExt175(VkDevice device) {
   1085     const struct loader_dev_dispatch_table *disp;
   1086     disp = loader_get_dev_dispatch(device);
   1087     disp->ext_dispatch.DevExt[175](device);
   1088 }
   1089 
   1090 VKAPI_ATTR void VKAPI_CALL vkDevExt176(VkDevice device) {
   1091     const struct loader_dev_dispatch_table *disp;
   1092     disp = loader_get_dev_dispatch(device);
   1093     disp->ext_dispatch.DevExt[176](device);
   1094 }
   1095 
   1096 VKAPI_ATTR void VKAPI_CALL vkDevExt177(VkDevice device) {
   1097     const struct loader_dev_dispatch_table *disp;
   1098     disp = loader_get_dev_dispatch(device);
   1099     disp->ext_dispatch.DevExt[177](device);
   1100 }
   1101 
   1102 VKAPI_ATTR void VKAPI_CALL vkDevExt178(VkDevice device) {
   1103     const struct loader_dev_dispatch_table *disp;
   1104     disp = loader_get_dev_dispatch(device);
   1105     disp->ext_dispatch.DevExt[178](device);
   1106 }
   1107 
   1108 VKAPI_ATTR void VKAPI_CALL vkDevExt179(VkDevice device) {
   1109     const struct loader_dev_dispatch_table *disp;
   1110     disp = loader_get_dev_dispatch(device);
   1111     disp->ext_dispatch.DevExt[179](device);
   1112 }
   1113 
   1114 VKAPI_ATTR void VKAPI_CALL vkDevExt180(VkDevice device) {
   1115     const struct loader_dev_dispatch_table *disp;
   1116     disp = loader_get_dev_dispatch(device);
   1117     disp->ext_dispatch.DevExt[180](device);
   1118 }
   1119 
   1120 VKAPI_ATTR void VKAPI_CALL vkDevExt181(VkDevice device) {
   1121     const struct loader_dev_dispatch_table *disp;
   1122     disp = loader_get_dev_dispatch(device);
   1123     disp->ext_dispatch.DevExt[181](device);
   1124 }
   1125 
   1126 VKAPI_ATTR void VKAPI_CALL vkDevExt182(VkDevice device) {
   1127     const struct loader_dev_dispatch_table *disp;
   1128     disp = loader_get_dev_dispatch(device);
   1129     disp->ext_dispatch.DevExt[182](device);
   1130 }
   1131 
   1132 VKAPI_ATTR void VKAPI_CALL vkDevExt183(VkDevice device) {
   1133     const struct loader_dev_dispatch_table *disp;
   1134     disp = loader_get_dev_dispatch(device);
   1135     disp->ext_dispatch.DevExt[183](device);
   1136 }
   1137 
   1138 VKAPI_ATTR void VKAPI_CALL vkDevExt184(VkDevice device) {
   1139     const struct loader_dev_dispatch_table *disp;
   1140     disp = loader_get_dev_dispatch(device);
   1141     disp->ext_dispatch.DevExt[184](device);
   1142 }
   1143 
   1144 VKAPI_ATTR void VKAPI_CALL vkDevExt185(VkDevice device) {
   1145     const struct loader_dev_dispatch_table *disp;
   1146     disp = loader_get_dev_dispatch(device);
   1147     disp->ext_dispatch.DevExt[185](device);
   1148 }
   1149 
   1150 VKAPI_ATTR void VKAPI_CALL vkDevExt186(VkDevice device) {
   1151     const struct loader_dev_dispatch_table *disp;
   1152     disp = loader_get_dev_dispatch(device);
   1153     disp->ext_dispatch.DevExt[186](device);
   1154 }
   1155 
   1156 VKAPI_ATTR void VKAPI_CALL vkDevExt187(VkDevice device) {
   1157     const struct loader_dev_dispatch_table *disp;
   1158     disp = loader_get_dev_dispatch(device);
   1159     disp->ext_dispatch.DevExt[187](device);
   1160 }
   1161 
   1162 VKAPI_ATTR void VKAPI_CALL vkDevExt188(VkDevice device) {
   1163     const struct loader_dev_dispatch_table *disp;
   1164     disp = loader_get_dev_dispatch(device);
   1165     disp->ext_dispatch.DevExt[188](device);
   1166 }
   1167 
   1168 VKAPI_ATTR void VKAPI_CALL vkDevExt189(VkDevice device) {
   1169     const struct loader_dev_dispatch_table *disp;
   1170     disp = loader_get_dev_dispatch(device);
   1171     disp->ext_dispatch.DevExt[189](device);
   1172 }
   1173 
   1174 VKAPI_ATTR void VKAPI_CALL vkDevExt190(VkDevice device) {
   1175     const struct loader_dev_dispatch_table *disp;
   1176     disp = loader_get_dev_dispatch(device);
   1177     disp->ext_dispatch.DevExt[190](device);
   1178 }
   1179 
   1180 VKAPI_ATTR void VKAPI_CALL vkDevExt191(VkDevice device) {
   1181     const struct loader_dev_dispatch_table *disp;
   1182     disp = loader_get_dev_dispatch(device);
   1183     disp->ext_dispatch.DevExt[191](device);
   1184 }
   1185 
   1186 VKAPI_ATTR void VKAPI_CALL vkDevExt192(VkDevice device) {
   1187     const struct loader_dev_dispatch_table *disp;
   1188     disp = loader_get_dev_dispatch(device);
   1189     disp->ext_dispatch.DevExt[192](device);
   1190 }
   1191 
   1192 VKAPI_ATTR void VKAPI_CALL vkDevExt193(VkDevice device) {
   1193     const struct loader_dev_dispatch_table *disp;
   1194     disp = loader_get_dev_dispatch(device);
   1195     disp->ext_dispatch.DevExt[193](device);
   1196 }
   1197 
   1198 VKAPI_ATTR void VKAPI_CALL vkDevExt194(VkDevice device) {
   1199     const struct loader_dev_dispatch_table *disp;
   1200     disp = loader_get_dev_dispatch(device);
   1201     disp->ext_dispatch.DevExt[194](device);
   1202 }
   1203 
   1204 VKAPI_ATTR void VKAPI_CALL vkDevExt195(VkDevice device) {
   1205     const struct loader_dev_dispatch_table *disp;
   1206     disp = loader_get_dev_dispatch(device);
   1207     disp->ext_dispatch.DevExt[195](device);
   1208 }
   1209 
   1210 VKAPI_ATTR void VKAPI_CALL vkDevExt196(VkDevice device) {
   1211     const struct loader_dev_dispatch_table *disp;
   1212     disp = loader_get_dev_dispatch(device);
   1213     disp->ext_dispatch.DevExt[196](device);
   1214 }
   1215 
   1216 VKAPI_ATTR void VKAPI_CALL vkDevExt197(VkDevice device) {
   1217     const struct loader_dev_dispatch_table *disp;
   1218     disp = loader_get_dev_dispatch(device);
   1219     disp->ext_dispatch.DevExt[197](device);
   1220 }
   1221 
   1222 VKAPI_ATTR void VKAPI_CALL vkDevExt198(VkDevice device) {
   1223     const struct loader_dev_dispatch_table *disp;
   1224     disp = loader_get_dev_dispatch(device);
   1225     disp->ext_dispatch.DevExt[198](device);
   1226 }
   1227 
   1228 VKAPI_ATTR void VKAPI_CALL vkDevExt199(VkDevice device) {
   1229     const struct loader_dev_dispatch_table *disp;
   1230     disp = loader_get_dev_dispatch(device);
   1231     disp->ext_dispatch.DevExt[199](device);
   1232 }
   1233 
   1234 VKAPI_ATTR void VKAPI_CALL vkDevExt200(VkDevice device) {
   1235     const struct loader_dev_dispatch_table *disp;
   1236     disp = loader_get_dev_dispatch(device);
   1237     disp->ext_dispatch.DevExt[200](device);
   1238 }
   1239 
   1240 VKAPI_ATTR void VKAPI_CALL vkDevExt201(VkDevice device) {
   1241     const struct loader_dev_dispatch_table *disp;
   1242     disp = loader_get_dev_dispatch(device);
   1243     disp->ext_dispatch.DevExt[201](device);
   1244 }
   1245 
   1246 VKAPI_ATTR void VKAPI_CALL vkDevExt202(VkDevice device) {
   1247     const struct loader_dev_dispatch_table *disp;
   1248     disp = loader_get_dev_dispatch(device);
   1249     disp->ext_dispatch.DevExt[202](device);
   1250 }
   1251 
   1252 VKAPI_ATTR void VKAPI_CALL vkDevExt203(VkDevice device) {
   1253     const struct loader_dev_dispatch_table *disp;
   1254     disp = loader_get_dev_dispatch(device);
   1255     disp->ext_dispatch.DevExt[203](device);
   1256 }
   1257 
   1258 VKAPI_ATTR void VKAPI_CALL vkDevExt204(VkDevice device) {
   1259     const struct loader_dev_dispatch_table *disp;
   1260     disp = loader_get_dev_dispatch(device);
   1261     disp->ext_dispatch.DevExt[204](device);
   1262 }
   1263 
   1264 VKAPI_ATTR void VKAPI_CALL vkDevExt205(VkDevice device) {
   1265     const struct loader_dev_dispatch_table *disp;
   1266     disp = loader_get_dev_dispatch(device);
   1267     disp->ext_dispatch.DevExt[205](device);
   1268 }
   1269 
   1270 VKAPI_ATTR void VKAPI_CALL vkDevExt206(VkDevice device) {
   1271     const struct loader_dev_dispatch_table *disp;
   1272     disp = loader_get_dev_dispatch(device);
   1273     disp->ext_dispatch.DevExt[206](device);
   1274 }
   1275 
   1276 VKAPI_ATTR void VKAPI_CALL vkDevExt207(VkDevice device) {
   1277     const struct loader_dev_dispatch_table *disp;
   1278     disp = loader_get_dev_dispatch(device);
   1279     disp->ext_dispatch.DevExt[207](device);
   1280 }
   1281 
   1282 VKAPI_ATTR void VKAPI_CALL vkDevExt208(VkDevice device) {
   1283     const struct loader_dev_dispatch_table *disp;
   1284     disp = loader_get_dev_dispatch(device);
   1285     disp->ext_dispatch.DevExt[208](device);
   1286 }
   1287 
   1288 VKAPI_ATTR void VKAPI_CALL vkDevExt209(VkDevice device) {
   1289     const struct loader_dev_dispatch_table *disp;
   1290     disp = loader_get_dev_dispatch(device);
   1291     disp->ext_dispatch.DevExt[209](device);
   1292 }
   1293 
   1294 VKAPI_ATTR void VKAPI_CALL vkDevExt210(VkDevice device) {
   1295     const struct loader_dev_dispatch_table *disp;
   1296     disp = loader_get_dev_dispatch(device);
   1297     disp->ext_dispatch.DevExt[210](device);
   1298 }
   1299 
   1300 VKAPI_ATTR void VKAPI_CALL vkDevExt211(VkDevice device) {
   1301     const struct loader_dev_dispatch_table *disp;
   1302     disp = loader_get_dev_dispatch(device);
   1303     disp->ext_dispatch.DevExt[211](device);
   1304 }
   1305 
   1306 VKAPI_ATTR void VKAPI_CALL vkDevExt212(VkDevice device) {
   1307     const struct loader_dev_dispatch_table *disp;
   1308     disp = loader_get_dev_dispatch(device);
   1309     disp->ext_dispatch.DevExt[212](device);
   1310 }
   1311 
   1312 VKAPI_ATTR void VKAPI_CALL vkDevExt213(VkDevice device) {
   1313     const struct loader_dev_dispatch_table *disp;
   1314     disp = loader_get_dev_dispatch(device);
   1315     disp->ext_dispatch.DevExt[213](device);
   1316 }
   1317 
   1318 VKAPI_ATTR void VKAPI_CALL vkDevExt214(VkDevice device) {
   1319     const struct loader_dev_dispatch_table *disp;
   1320     disp = loader_get_dev_dispatch(device);
   1321     disp->ext_dispatch.DevExt[214](device);
   1322 }
   1323 
   1324 VKAPI_ATTR void VKAPI_CALL vkDevExt215(VkDevice device) {
   1325     const struct loader_dev_dispatch_table *disp;
   1326     disp = loader_get_dev_dispatch(device);
   1327     disp->ext_dispatch.DevExt[215](device);
   1328 }
   1329 
   1330 VKAPI_ATTR void VKAPI_CALL vkDevExt216(VkDevice device) {
   1331     const struct loader_dev_dispatch_table *disp;
   1332     disp = loader_get_dev_dispatch(device);
   1333     disp->ext_dispatch.DevExt[216](device);
   1334 }
   1335 
   1336 VKAPI_ATTR void VKAPI_CALL vkDevExt217(VkDevice device) {
   1337     const struct loader_dev_dispatch_table *disp;
   1338     disp = loader_get_dev_dispatch(device);
   1339     disp->ext_dispatch.DevExt[217](device);
   1340 }
   1341 
   1342 VKAPI_ATTR void VKAPI_CALL vkDevExt218(VkDevice device) {
   1343     const struct loader_dev_dispatch_table *disp;
   1344     disp = loader_get_dev_dispatch(device);
   1345     disp->ext_dispatch.DevExt[218](device);
   1346 }
   1347 
   1348 VKAPI_ATTR void VKAPI_CALL vkDevExt219(VkDevice device) {
   1349     const struct loader_dev_dispatch_table *disp;
   1350     disp = loader_get_dev_dispatch(device);
   1351     disp->ext_dispatch.DevExt[219](device);
   1352 }
   1353 
   1354 VKAPI_ATTR void VKAPI_CALL vkDevExt220(VkDevice device) {
   1355     const struct loader_dev_dispatch_table *disp;
   1356     disp = loader_get_dev_dispatch(device);
   1357     disp->ext_dispatch.DevExt[220](device);
   1358 }
   1359 
   1360 VKAPI_ATTR void VKAPI_CALL vkDevExt221(VkDevice device) {
   1361     const struct loader_dev_dispatch_table *disp;
   1362     disp = loader_get_dev_dispatch(device);
   1363     disp->ext_dispatch.DevExt[221](device);
   1364 }
   1365 
   1366 VKAPI_ATTR void VKAPI_CALL vkDevExt222(VkDevice device) {
   1367     const struct loader_dev_dispatch_table *disp;
   1368     disp = loader_get_dev_dispatch(device);
   1369     disp->ext_dispatch.DevExt[222](device);
   1370 }
   1371 
   1372 VKAPI_ATTR void VKAPI_CALL vkDevExt223(VkDevice device) {
   1373     const struct loader_dev_dispatch_table *disp;
   1374     disp = loader_get_dev_dispatch(device);
   1375     disp->ext_dispatch.DevExt[223](device);
   1376 }
   1377 
   1378 VKAPI_ATTR void VKAPI_CALL vkDevExt224(VkDevice device) {
   1379     const struct loader_dev_dispatch_table *disp;
   1380     disp = loader_get_dev_dispatch(device);
   1381     disp->ext_dispatch.DevExt[224](device);
   1382 }
   1383 
   1384 VKAPI_ATTR void VKAPI_CALL vkDevExt225(VkDevice device) {
   1385     const struct loader_dev_dispatch_table *disp;
   1386     disp = loader_get_dev_dispatch(device);
   1387     disp->ext_dispatch.DevExt[225](device);
   1388 }
   1389 
   1390 VKAPI_ATTR void VKAPI_CALL vkDevExt226(VkDevice device) {
   1391     const struct loader_dev_dispatch_table *disp;
   1392     disp = loader_get_dev_dispatch(device);
   1393     disp->ext_dispatch.DevExt[226](device);
   1394 }
   1395 
   1396 VKAPI_ATTR void VKAPI_CALL vkDevExt227(VkDevice device) {
   1397     const struct loader_dev_dispatch_table *disp;
   1398     disp = loader_get_dev_dispatch(device);
   1399     disp->ext_dispatch.DevExt[227](device);
   1400 }
   1401 
   1402 VKAPI_ATTR void VKAPI_CALL vkDevExt228(VkDevice device) {
   1403     const struct loader_dev_dispatch_table *disp;
   1404     disp = loader_get_dev_dispatch(device);
   1405     disp->ext_dispatch.DevExt[228](device);
   1406 }
   1407 
   1408 VKAPI_ATTR void VKAPI_CALL vkDevExt229(VkDevice device) {
   1409     const struct loader_dev_dispatch_table *disp;
   1410     disp = loader_get_dev_dispatch(device);
   1411     disp->ext_dispatch.DevExt[229](device);
   1412 }
   1413 
   1414 VKAPI_ATTR void VKAPI_CALL vkDevExt230(VkDevice device) {
   1415     const struct loader_dev_dispatch_table *disp;
   1416     disp = loader_get_dev_dispatch(device);
   1417     disp->ext_dispatch.DevExt[230](device);
   1418 }
   1419 
   1420 VKAPI_ATTR void VKAPI_CALL vkDevExt231(VkDevice device) {
   1421     const struct loader_dev_dispatch_table *disp;
   1422     disp = loader_get_dev_dispatch(device);
   1423     disp->ext_dispatch.DevExt[231](device);
   1424 }
   1425 
   1426 VKAPI_ATTR void VKAPI_CALL vkDevExt232(VkDevice device) {
   1427     const struct loader_dev_dispatch_table *disp;
   1428     disp = loader_get_dev_dispatch(device);
   1429     disp->ext_dispatch.DevExt[232](device);
   1430 }
   1431 
   1432 VKAPI_ATTR void VKAPI_CALL vkDevExt233(VkDevice device) {
   1433     const struct loader_dev_dispatch_table *disp;
   1434     disp = loader_get_dev_dispatch(device);
   1435     disp->ext_dispatch.DevExt[233](device);
   1436 }
   1437 
   1438 VKAPI_ATTR void VKAPI_CALL vkDevExt234(VkDevice device) {
   1439     const struct loader_dev_dispatch_table *disp;
   1440     disp = loader_get_dev_dispatch(device);
   1441     disp->ext_dispatch.DevExt[234](device);
   1442 }
   1443 
   1444 VKAPI_ATTR void VKAPI_CALL vkDevExt235(VkDevice device) {
   1445     const struct loader_dev_dispatch_table *disp;
   1446     disp = loader_get_dev_dispatch(device);
   1447     disp->ext_dispatch.DevExt[235](device);
   1448 }
   1449 
   1450 VKAPI_ATTR void VKAPI_CALL vkDevExt236(VkDevice device) {
   1451     const struct loader_dev_dispatch_table *disp;
   1452     disp = loader_get_dev_dispatch(device);
   1453     disp->ext_dispatch.DevExt[236](device);
   1454 }
   1455 
   1456 VKAPI_ATTR void VKAPI_CALL vkDevExt237(VkDevice device) {
   1457     const struct loader_dev_dispatch_table *disp;
   1458     disp = loader_get_dev_dispatch(device);
   1459     disp->ext_dispatch.DevExt[237](device);
   1460 }
   1461 
   1462 VKAPI_ATTR void VKAPI_CALL vkDevExt238(VkDevice device) {
   1463     const struct loader_dev_dispatch_table *disp;
   1464     disp = loader_get_dev_dispatch(device);
   1465     disp->ext_dispatch.DevExt[238](device);
   1466 }
   1467 
   1468 VKAPI_ATTR void VKAPI_CALL vkDevExt239(VkDevice device) {
   1469     const struct loader_dev_dispatch_table *disp;
   1470     disp = loader_get_dev_dispatch(device);
   1471     disp->ext_dispatch.DevExt[239](device);
   1472 }
   1473 
   1474 VKAPI_ATTR void VKAPI_CALL vkDevExt240(VkDevice device) {
   1475     const struct loader_dev_dispatch_table *disp;
   1476     disp = loader_get_dev_dispatch(device);
   1477     disp->ext_dispatch.DevExt[240](device);
   1478 }
   1479 
   1480 VKAPI_ATTR void VKAPI_CALL vkDevExt241(VkDevice device) {
   1481     const struct loader_dev_dispatch_table *disp;
   1482     disp = loader_get_dev_dispatch(device);
   1483     disp->ext_dispatch.DevExt[241](device);
   1484 }
   1485 
   1486 VKAPI_ATTR void VKAPI_CALL vkDevExt242(VkDevice device) {
   1487     const struct loader_dev_dispatch_table *disp;
   1488     disp = loader_get_dev_dispatch(device);
   1489     disp->ext_dispatch.DevExt[242](device);
   1490 }
   1491 
   1492 VKAPI_ATTR void VKAPI_CALL vkDevExt243(VkDevice device) {
   1493     const struct loader_dev_dispatch_table *disp;
   1494     disp = loader_get_dev_dispatch(device);
   1495     disp->ext_dispatch.DevExt[243](device);
   1496 }
   1497 
   1498 VKAPI_ATTR void VKAPI_CALL vkDevExt244(VkDevice device) {
   1499     const struct loader_dev_dispatch_table *disp;
   1500     disp = loader_get_dev_dispatch(device);
   1501     disp->ext_dispatch.DevExt[244](device);
   1502 }
   1503 
   1504 VKAPI_ATTR void VKAPI_CALL vkDevExt245(VkDevice device) {
   1505     const struct loader_dev_dispatch_table *disp;
   1506     disp = loader_get_dev_dispatch(device);
   1507     disp->ext_dispatch.DevExt[245](device);
   1508 }
   1509 
   1510 VKAPI_ATTR void VKAPI_CALL vkDevExt246(VkDevice device) {
   1511     const struct loader_dev_dispatch_table *disp;
   1512     disp = loader_get_dev_dispatch(device);
   1513     disp->ext_dispatch.DevExt[246](device);
   1514 }
   1515 
   1516 VKAPI_ATTR void VKAPI_CALL vkDevExt247(VkDevice device) {
   1517     const struct loader_dev_dispatch_table *disp;
   1518     disp = loader_get_dev_dispatch(device);
   1519     disp->ext_dispatch.DevExt[247](device);
   1520 }
   1521 
   1522 VKAPI_ATTR void VKAPI_CALL vkDevExt248(VkDevice device) {
   1523     const struct loader_dev_dispatch_table *disp;
   1524     disp = loader_get_dev_dispatch(device);
   1525     disp->ext_dispatch.DevExt[248](device);
   1526 }
   1527 
   1528 VKAPI_ATTR void VKAPI_CALL vkDevExt249(VkDevice device) {
   1529     const struct loader_dev_dispatch_table *disp;
   1530     disp = loader_get_dev_dispatch(device);
   1531     disp->ext_dispatch.DevExt[249](device);
   1532 }
   1533 
   1534 void *loader_get_dev_ext_trampoline(uint32_t index) {
   1535     switch (index) {
   1536     case 0:
   1537         return vkDevExt0;
   1538     case 1:
   1539         return vkDevExt1;
   1540     case 2:
   1541         return vkDevExt2;
   1542     case 3:
   1543         return vkDevExt3;
   1544     case 4:
   1545         return vkDevExt4;
   1546     case 5:
   1547         return vkDevExt5;
   1548     case 6:
   1549         return vkDevExt6;
   1550     case 7:
   1551         return vkDevExt7;
   1552     case 8:
   1553         return vkDevExt8;
   1554     case 9:
   1555         return vkDevExt9;
   1556     case 10:
   1557         return vkDevExt10;
   1558     case 11:
   1559         return vkDevExt11;
   1560     case 12:
   1561         return vkDevExt12;
   1562     case 13:
   1563         return vkDevExt13;
   1564     case 14:
   1565         return vkDevExt14;
   1566     case 15:
   1567         return vkDevExt15;
   1568     case 16:
   1569         return vkDevExt16;
   1570     case 17:
   1571         return vkDevExt17;
   1572     case 18:
   1573         return vkDevExt18;
   1574     case 19:
   1575         return vkDevExt19;
   1576     case 20:
   1577         return vkDevExt20;
   1578     case 21:
   1579         return vkDevExt21;
   1580     case 22:
   1581         return vkDevExt22;
   1582     case 23:
   1583         return vkDevExt23;
   1584     case 24:
   1585         return vkDevExt24;
   1586     case 25:
   1587         return vkDevExt25;
   1588     case 26:
   1589         return vkDevExt26;
   1590     case 27:
   1591         return vkDevExt27;
   1592     case 28:
   1593         return vkDevExt28;
   1594     case 29:
   1595         return vkDevExt29;
   1596     case 30:
   1597         return vkDevExt30;
   1598     case 31:
   1599         return vkDevExt31;
   1600     case 32:
   1601         return vkDevExt32;
   1602     case 33:
   1603         return vkDevExt33;
   1604     case 34:
   1605         return vkDevExt34;
   1606     case 35:
   1607         return vkDevExt35;
   1608     case 36:
   1609         return vkDevExt36;
   1610     case 37:
   1611         return vkDevExt37;
   1612     case 38:
   1613         return vkDevExt38;
   1614     case 39:
   1615         return vkDevExt39;
   1616     case 40:
   1617         return vkDevExt40;
   1618     case 41:
   1619         return vkDevExt41;
   1620     case 42:
   1621         return vkDevExt42;
   1622     case 43:
   1623         return vkDevExt43;
   1624     case 44:
   1625         return vkDevExt44;
   1626     case 45:
   1627         return vkDevExt45;
   1628     case 46:
   1629         return vkDevExt46;
   1630     case 47:
   1631         return vkDevExt47;
   1632     case 48:
   1633         return vkDevExt48;
   1634     case 49:
   1635         return vkDevExt49;
   1636     case 50:
   1637         return vkDevExt50;
   1638     case 51:
   1639         return vkDevExt51;
   1640     case 52:
   1641         return vkDevExt52;
   1642     case 53:
   1643         return vkDevExt53;
   1644     case 54:
   1645         return vkDevExt54;
   1646     case 55:
   1647         return vkDevExt55;
   1648     case 56:
   1649         return vkDevExt56;
   1650     case 57:
   1651         return vkDevExt57;
   1652     case 58:
   1653         return vkDevExt58;
   1654     case 59:
   1655         return vkDevExt59;
   1656     case 60:
   1657         return vkDevExt60;
   1658     case 61:
   1659         return vkDevExt61;
   1660     case 62:
   1661         return vkDevExt62;
   1662     case 63:
   1663         return vkDevExt63;
   1664     case 64:
   1665         return vkDevExt64;
   1666     case 65:
   1667         return vkDevExt65;
   1668     case 66:
   1669         return vkDevExt66;
   1670     case 67:
   1671         return vkDevExt67;
   1672     case 68:
   1673         return vkDevExt68;
   1674     case 69:
   1675         return vkDevExt69;
   1676     case 70:
   1677         return vkDevExt70;
   1678     case 71:
   1679         return vkDevExt71;
   1680     case 72:
   1681         return vkDevExt72;
   1682     case 73:
   1683         return vkDevExt73;
   1684     case 74:
   1685         return vkDevExt74;
   1686     case 75:
   1687         return vkDevExt75;
   1688     case 76:
   1689         return vkDevExt76;
   1690     case 77:
   1691         return vkDevExt77;
   1692     case 78:
   1693         return vkDevExt78;
   1694     case 79:
   1695         return vkDevExt79;
   1696     case 80:
   1697         return vkDevExt80;
   1698     case 81:
   1699         return vkDevExt81;
   1700     case 82:
   1701         return vkDevExt82;
   1702     case 83:
   1703         return vkDevExt83;
   1704     case 84:
   1705         return vkDevExt84;
   1706     case 85:
   1707         return vkDevExt85;
   1708     case 86:
   1709         return vkDevExt86;
   1710     case 87:
   1711         return vkDevExt87;
   1712     case 88:
   1713         return vkDevExt88;
   1714     case 89:
   1715         return vkDevExt89;
   1716     case 90:
   1717         return vkDevExt90;
   1718     case 91:
   1719         return vkDevExt91;
   1720     case 92:
   1721         return vkDevExt92;
   1722     case 93:
   1723         return vkDevExt93;
   1724     case 94:
   1725         return vkDevExt94;
   1726     case 95:
   1727         return vkDevExt95;
   1728     case 96:
   1729         return vkDevExt96;
   1730     case 97:
   1731         return vkDevExt97;
   1732     case 98:
   1733         return vkDevExt98;
   1734     case 99:
   1735         return vkDevExt99;
   1736     case 100:
   1737         return vkDevExt100;
   1738     case 101:
   1739         return vkDevExt101;
   1740     case 102:
   1741         return vkDevExt102;
   1742     case 103:
   1743         return vkDevExt103;
   1744     case 104:
   1745         return vkDevExt104;
   1746     case 105:
   1747         return vkDevExt105;
   1748     case 106:
   1749         return vkDevExt106;
   1750     case 107:
   1751         return vkDevExt107;
   1752     case 108:
   1753         return vkDevExt108;
   1754     case 109:
   1755         return vkDevExt109;
   1756     case 110:
   1757         return vkDevExt110;
   1758     case 111:
   1759         return vkDevExt111;
   1760     case 112:
   1761         return vkDevExt112;
   1762     case 113:
   1763         return vkDevExt113;
   1764     case 114:
   1765         return vkDevExt114;
   1766     case 115:
   1767         return vkDevExt115;
   1768     case 116:
   1769         return vkDevExt116;
   1770     case 117:
   1771         return vkDevExt117;
   1772     case 118:
   1773         return vkDevExt118;
   1774     case 119:
   1775         return vkDevExt119;
   1776     case 120:
   1777         return vkDevExt120;
   1778     case 121:
   1779         return vkDevExt121;
   1780     case 122:
   1781         return vkDevExt122;
   1782     case 123:
   1783         return vkDevExt123;
   1784     case 124:
   1785         return vkDevExt124;
   1786     case 125:
   1787         return vkDevExt125;
   1788     case 126:
   1789         return vkDevExt126;
   1790     case 127:
   1791         return vkDevExt127;
   1792     case 128:
   1793         return vkDevExt128;
   1794     case 129:
   1795         return vkDevExt129;
   1796     case 130:
   1797         return vkDevExt130;
   1798     case 131:
   1799         return vkDevExt131;
   1800     case 132:
   1801         return vkDevExt132;
   1802     case 133:
   1803         return vkDevExt133;
   1804     case 134:
   1805         return vkDevExt134;
   1806     case 135:
   1807         return vkDevExt135;
   1808     case 136:
   1809         return vkDevExt136;
   1810     case 137:
   1811         return vkDevExt137;
   1812     case 138:
   1813         return vkDevExt138;
   1814     case 139:
   1815         return vkDevExt139;
   1816     case 140:
   1817         return vkDevExt140;
   1818     case 141:
   1819         return vkDevExt141;
   1820     case 142:
   1821         return vkDevExt142;
   1822     case 143:
   1823         return vkDevExt143;
   1824     case 144:
   1825         return vkDevExt144;
   1826     case 145:
   1827         return vkDevExt145;
   1828     case 146:
   1829         return vkDevExt146;
   1830     case 147:
   1831         return vkDevExt147;
   1832     case 148:
   1833         return vkDevExt148;
   1834     case 149:
   1835         return vkDevExt149;
   1836     case 150:
   1837         return vkDevExt150;
   1838     case 151:
   1839         return vkDevExt151;
   1840     case 152:
   1841         return vkDevExt152;
   1842     case 153:
   1843         return vkDevExt153;
   1844     case 154:
   1845         return vkDevExt154;
   1846     case 155:
   1847         return vkDevExt155;
   1848     case 156:
   1849         return vkDevExt156;
   1850     case 157:
   1851         return vkDevExt157;
   1852     case 158:
   1853         return vkDevExt158;
   1854     case 159:
   1855         return vkDevExt159;
   1856     case 160:
   1857         return vkDevExt160;
   1858     case 161:
   1859         return vkDevExt161;
   1860     case 162:
   1861         return vkDevExt162;
   1862     case 163:
   1863         return vkDevExt163;
   1864     case 164:
   1865         return vkDevExt164;
   1866     case 165:
   1867         return vkDevExt165;
   1868     case 166:
   1869         return vkDevExt166;
   1870     case 167:
   1871         return vkDevExt167;
   1872     case 168:
   1873         return vkDevExt168;
   1874     case 169:
   1875         return vkDevExt169;
   1876     case 170:
   1877         return vkDevExt170;
   1878     case 171:
   1879         return vkDevExt171;
   1880     case 172:
   1881         return vkDevExt172;
   1882     case 173:
   1883         return vkDevExt173;
   1884     case 174:
   1885         return vkDevExt174;
   1886     case 175:
   1887         return vkDevExt175;
   1888     case 176:
   1889         return vkDevExt176;
   1890     case 177:
   1891         return vkDevExt177;
   1892     case 178:
   1893         return vkDevExt178;
   1894     case 179:
   1895         return vkDevExt179;
   1896     case 180:
   1897         return vkDevExt180;
   1898     case 181:
   1899         return vkDevExt181;
   1900     case 182:
   1901         return vkDevExt182;
   1902     case 183:
   1903         return vkDevExt183;
   1904     case 184:
   1905         return vkDevExt184;
   1906     case 185:
   1907         return vkDevExt185;
   1908     case 186:
   1909         return vkDevExt186;
   1910     case 187:
   1911         return vkDevExt187;
   1912     case 188:
   1913         return vkDevExt188;
   1914     case 189:
   1915         return vkDevExt189;
   1916     case 190:
   1917         return vkDevExt190;
   1918     case 191:
   1919         return vkDevExt191;
   1920     case 192:
   1921         return vkDevExt192;
   1922     case 193:
   1923         return vkDevExt193;
   1924     case 194:
   1925         return vkDevExt194;
   1926     case 195:
   1927         return vkDevExt195;
   1928     case 196:
   1929         return vkDevExt196;
   1930     case 197:
   1931         return vkDevExt197;
   1932     case 198:
   1933         return vkDevExt198;
   1934     case 199:
   1935         return vkDevExt199;
   1936     case 200:
   1937         return vkDevExt200;
   1938     case 201:
   1939         return vkDevExt201;
   1940     case 202:
   1941         return vkDevExt202;
   1942     case 203:
   1943         return vkDevExt203;
   1944     case 204:
   1945         return vkDevExt204;
   1946     case 205:
   1947         return vkDevExt205;
   1948     case 206:
   1949         return vkDevExt206;
   1950     case 207:
   1951         return vkDevExt207;
   1952     case 208:
   1953         return vkDevExt208;
   1954     case 209:
   1955         return vkDevExt209;
   1956     case 210:
   1957         return vkDevExt210;
   1958     case 211:
   1959         return vkDevExt211;
   1960     case 212:
   1961         return vkDevExt212;
   1962     case 213:
   1963         return vkDevExt213;
   1964     case 214:
   1965         return vkDevExt214;
   1966     case 215:
   1967         return vkDevExt215;
   1968     case 216:
   1969         return vkDevExt216;
   1970     case 217:
   1971         return vkDevExt217;
   1972     case 218:
   1973         return vkDevExt218;
   1974     case 219:
   1975         return vkDevExt219;
   1976     case 220:
   1977         return vkDevExt220;
   1978     case 221:
   1979         return vkDevExt221;
   1980     case 222:
   1981         return vkDevExt222;
   1982     case 223:
   1983         return vkDevExt223;
   1984     case 224:
   1985         return vkDevExt224;
   1986     case 225:
   1987         return vkDevExt225;
   1988     case 226:
   1989         return vkDevExt226;
   1990     case 227:
   1991         return vkDevExt227;
   1992     case 228:
   1993         return vkDevExt228;
   1994     case 229:
   1995         return vkDevExt229;
   1996     case 230:
   1997         return vkDevExt230;
   1998     case 231:
   1999         return vkDevExt231;
   2000     case 232:
   2001         return vkDevExt232;
   2002     case 233:
   2003         return vkDevExt233;
   2004     case 234:
   2005         return vkDevExt234;
   2006     case 235:
   2007         return vkDevExt235;
   2008     case 236:
   2009         return vkDevExt236;
   2010     case 237:
   2011         return vkDevExt237;
   2012     case 238:
   2013         return vkDevExt238;
   2014     case 239:
   2015         return vkDevExt239;
   2016     case 240:
   2017         return vkDevExt240;
   2018     case 241:
   2019         return vkDevExt241;
   2020     case 242:
   2021         return vkDevExt242;
   2022     case 243:
   2023         return vkDevExt243;
   2024     case 244:
   2025         return vkDevExt244;
   2026     case 245:
   2027         return vkDevExt245;
   2028     case 246:
   2029         return vkDevExt246;
   2030     case 247:
   2031         return vkDevExt247;
   2032     case 248:
   2033         return vkDevExt248;
   2034     case 249:
   2035         return vkDevExt249;
   2036     }
   2037     return NULL;
   2038 }
   2039