xref: /external/vulkan-validation-layers/loader/dev_ext_trampoline.c

/*
 * Copyright (c) 2015-2016 The Khronos Group Inc.
 * Copyright (c) 2015-2016 Valve Corporation
 * Copyright (c) 2015-2016 LunarG, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and/or associated documentation files (the "Materials"), to
 * deal in the Materials without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Materials, and to permit persons to whom the Materials are
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice(s) and this permission notice shall be included in
 * all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
 * USE OR OTHER DEALINGS IN THE MATERIALS.
 *
 * Author: Jon Ashburn <jon@lunarg.com>
 */

#include "vk_loader_platform.h"
#include "loader.h"
#if defined(__linux__)
#pragma GCC optimize(3) // force gcc to use tail-calls
#endif

VKAPI_ATTR void VKAPI_CALL vkDevExt0(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[0](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt1(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[1](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt2(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[2](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt3(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[3](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt4(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[4](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt5(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[5](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt6(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[6](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt7(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[7](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt8(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[8](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt9(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[9](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt10(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[10](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt11(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[11](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt12(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[12](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt13(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[13](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt14(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[14](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt15(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[15](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt16(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[16](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt17(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[17](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt18(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[18](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt19(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[19](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt20(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[20](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt21(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[21](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt22(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[22](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt23(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[23](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt24(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[24](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt25(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[25](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt26(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[26](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt27(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[27](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt28(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[28](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt29(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[29](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt30(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[30](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt31(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[31](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt32(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[32](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt33(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[33](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt34(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[34](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt35(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[35](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt36(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[36](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt37(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[37](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt38(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[38](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt39(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[39](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt40(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[40](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt41(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[41](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt42(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[42](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt43(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[43](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt44(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[44](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt45(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[45](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt46(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[46](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt47(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[47](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt48(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[48](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt49(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[49](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt50(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[50](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt51(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[51](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt52(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[52](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt53(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[53](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt54(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[54](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt55(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[55](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt56(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[56](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt57(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[57](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt58(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[58](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt59(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[59](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt60(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[60](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt61(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[61](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt62(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[62](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt63(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[63](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt64(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[64](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt65(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[65](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt66(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[66](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt67(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[67](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt68(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[68](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt69(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[69](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt70(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[70](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt71(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[71](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt72(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[72](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt73(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[73](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt74(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[74](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt75(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[75](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt76(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[76](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt77(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[77](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt78(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[78](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt79(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[79](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt80(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[80](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt81(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[81](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt82(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[82](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt83(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[83](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt84(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[84](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt85(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[85](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt86(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[86](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt87(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[87](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt88(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[88](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt89(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[89](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt90(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[90](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt91(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[91](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt92(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[92](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt93(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[93](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt94(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[94](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt95(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[95](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt96(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[96](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt97(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[97](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt98(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[98](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt99(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[99](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt100(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[100](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt101(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[101](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt102(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[102](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt103(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[103](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt104(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[104](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt105(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[105](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt106(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[106](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt107(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[107](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt108(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[108](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt109(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[109](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt110(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[110](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt111(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[111](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt112(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[112](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt113(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[113](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt114(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[114](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt115(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[115](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt116(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[116](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt117(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[117](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt118(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[118](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt119(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[119](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt120(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[120](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt121(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[121](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt122(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[122](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt123(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[123](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt124(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[124](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt125(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[125](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt126(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[126](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt127(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[127](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt128(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[128](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt129(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[129](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt130(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[130](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt131(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[131](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt132(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[132](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt133(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[133](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt134(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[134](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt135(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[135](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt136(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[136](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt137(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[137](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt138(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[138](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt139(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[139](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt140(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[140](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt141(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[141](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt142(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[142](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt143(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[143](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt144(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[144](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt145(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[145](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt146(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[146](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt147(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[147](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt148(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[148](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt149(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[149](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt150(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[150](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt151(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[151](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt152(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[152](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt153(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[153](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt154(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[154](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt155(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[155](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt156(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[156](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt157(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[157](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt158(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[158](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt159(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[159](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt160(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[160](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt161(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[161](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt162(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[162](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt163(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[163](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt164(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[164](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt165(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[165](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt166(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[166](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt167(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[167](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt168(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[168](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt169(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[169](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt170(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[170](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt171(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[171](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt172(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[172](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt173(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[173](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt174(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[174](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt175(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[175](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt176(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[176](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt177(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[177](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt178(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[178](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt179(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[179](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt180(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[180](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt181(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[181](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt182(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[182](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt183(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[183](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt184(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[184](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt185(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[185](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt186(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[186](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt187(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[187](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt188(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[188](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt189(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[189](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt190(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[190](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt191(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[191](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt192(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[192](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt193(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[193](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt194(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[194](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt195(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[195](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt196(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[196](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt197(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[197](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt198(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[198](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt199(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[199](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt200(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[200](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt201(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[201](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt202(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[202](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt203(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[203](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt204(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[204](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt205(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[205](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt206(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[206](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt207(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[207](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt208(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[208](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt209(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[209](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt210(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[210](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt211(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[211](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt212(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[212](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt213(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[213](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt214(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[214](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt215(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[215](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt216(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[216](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt217(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[217](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt218(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[218](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt219(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[219](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt220(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[220](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt221(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[221](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt222(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[222](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt223(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[223](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt224(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[224](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt225(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[225](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt226(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[226](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt227(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[227](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt228(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[228](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt229(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[229](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt230(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[230](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt231(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[231](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt232(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[232](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt233(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[233](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt234(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[234](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt235(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[235](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt236(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[236](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt237(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[237](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt238(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[238](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt239(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[239](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt240(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[240](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt241(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[241](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt242(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[242](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt243(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[243](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt244(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[244](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt245(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[245](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt246(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[246](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt247(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[247](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt248(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[248](device);
}

VKAPI_ATTR void VKAPI_CALL vkDevExt249(VkDevice device) {
    const struct loader_dev_dispatch_table *disp;
    disp = loader_get_dev_dispatch(device);
    disp->ext_dispatch.DevExt[249](device);
}

void *loader_get_dev_ext_trampoline(uint32_t index) {
    switch (index) {
    case 0:
        return vkDevExt0;
    case 1:
        return vkDevExt1;
    case 2:
        return vkDevExt2;
    case 3:
        return vkDevExt3;
    case 4:
        return vkDevExt4;
    case 5:
        return vkDevExt5;
    case 6:
        return vkDevExt6;
    case 7:
        return vkDevExt7;
    case 8:
        return vkDevExt8;
    case 9:
        return vkDevExt9;
    case 10:
        return vkDevExt10;
    case 11:
        return vkDevExt11;
    case 12:
        return vkDevExt12;
    case 13:
        return vkDevExt13;
    case 14:
        return vkDevExt14;
    case 15:
        return vkDevExt15;
    case 16:
        return vkDevExt16;
    case 17:
        return vkDevExt17;
    case 18:
        return vkDevExt18;
    case 19:
        return vkDevExt19;
    case 20:
        return vkDevExt20;
    case 21:
        return vkDevExt21;
    case 22:
        return vkDevExt22;
    case 23:
        return vkDevExt23;
    case 24:
        return vkDevExt24;
    case 25:
        return vkDevExt25;
    case 26:
        return vkDevExt26;
    case 27:
        return vkDevExt27;
    case 28:
        return vkDevExt28;
    case 29:
        return vkDevExt29;
    case 30:
        return vkDevExt30;
    case 31:
        return vkDevExt31;
    case 32:
        return vkDevExt32;
    case 33:
        return vkDevExt33;
    case 34:
        return vkDevExt34;
    case 35:
        return vkDevExt35;
    case 36:
        return vkDevExt36;
    case 37:
        return vkDevExt37;
    case 38:
        return vkDevExt38;
    case 39:
        return vkDevExt39;
    case 40:
        return vkDevExt40;
    case 41:
        return vkDevExt41;
    case 42:
        return vkDevExt42;
    case 43:
        return vkDevExt43;
    case 44:
        return vkDevExt44;
    case 45:
        return vkDevExt45;
    case 46:
        return vkDevExt46;
    case 47:
        return vkDevExt47;
    case 48:
        return vkDevExt48;
    case 49:
        return vkDevExt49;
    case 50:
        return vkDevExt50;
    case 51:
        return vkDevExt51;
    case 52:
        return vkDevExt52;
    case 53:
        return vkDevExt53;
    case 54:
        return vkDevExt54;
    case 55:
        return vkDevExt55;
    case 56:
        return vkDevExt56;
    case 57:
        return vkDevExt57;
    case 58:
        return vkDevExt58;
    case 59:
        return vkDevExt59;
    case 60:
        return vkDevExt60;
    case 61:
        return vkDevExt61;
    case 62:
        return vkDevExt62;
    case 63:
        return vkDevExt63;
    case 64:
        return vkDevExt64;
    case 65:
        return vkDevExt65;
    case 66:
        return vkDevExt66;
    case 67:
        return vkDevExt67;
    case 68:
        return vkDevExt68;
    case 69:
        return vkDevExt69;
    case 70:
        return vkDevExt70;
    case 71:
        return vkDevExt71;
    case 72:
        return vkDevExt72;
    case 73:
        return vkDevExt73;
    case 74:
        return vkDevExt74;
    case 75:
        return vkDevExt75;
    case 76:
        return vkDevExt76;
    case 77:
        return vkDevExt77;
    case 78:
        return vkDevExt78;
    case 79:
        return vkDevExt79;
    case 80:
        return vkDevExt80;
    case 81:
        return vkDevExt81;
    case 82:
        return vkDevExt82;
    case 83:
        return vkDevExt83;
    case 84:
        return vkDevExt84;
    case 85:
        return vkDevExt85;
    case 86:
        return vkDevExt86;
    case 87:
        return vkDevExt87;
    case 88:
        return vkDevExt88;
    case 89:
        return vkDevExt89;
    case 90:
        return vkDevExt90;
    case 91:
        return vkDevExt91;
    case 92:
        return vkDevExt92;
    case 93:
        return vkDevExt93;
    case 94:
        return vkDevExt94;
    case 95:
        return vkDevExt95;
    case 96:
        return vkDevExt96;
    case 97:
        return vkDevExt97;
    case 98:
        return vkDevExt98;
    case 99:
        return vkDevExt99;
    case 100:
        return vkDevExt100;
    case 101:
        return vkDevExt101;
    case 102:
        return vkDevExt102;
    case 103:
        return vkDevExt103;
    case 104:
        return vkDevExt104;
    case 105:
        return vkDevExt105;
    case 106:
        return vkDevExt106;
    case 107:
        return vkDevExt107;
    case 108:
        return vkDevExt108;
    case 109:
        return vkDevExt109;
    case 110:
        return vkDevExt110;
    case 111:
        return vkDevExt111;
    case 112:
        return vkDevExt112;
    case 113:
        return vkDevExt113;
    case 114:
        return vkDevExt114;
    case 115:
        return vkDevExt115;
    case 116:
        return vkDevExt116;
    case 117:
        return vkDevExt117;
    case 118:
        return vkDevExt118;
    case 119:
        return vkDevExt119;
    case 120:
        return vkDevExt120;
    case 121:
        return vkDevExt121;
    case 122:
        return vkDevExt122;
    case 123:
        return vkDevExt123;
    case 124:
        return vkDevExt124;
    case 125:
        return vkDevExt125;
    case 126:
        return vkDevExt126;
    case 127:
        return vkDevExt127;
    case 128:
        return vkDevExt128;
    case 129:
        return vkDevExt129;
    case 130:
        return vkDevExt130;
    case 131:
        return vkDevExt131;
    case 132:
        return vkDevExt132;
    case 133:
        return vkDevExt133;
    case 134:
        return vkDevExt134;
    case 135:
        return vkDevExt135;
    case 136:
        return vkDevExt136;
    case 137:
        return vkDevExt137;
    case 138:
        return vkDevExt138;
    case 139:
        return vkDevExt139;
    case 140:
        return vkDevExt140;
    case 141:
        return vkDevExt141;
    case 142:
        return vkDevExt142;
    case 143:
        return vkDevExt143;
    case 144:
        return vkDevExt144;
    case 145:
        return vkDevExt145;
    case 146:
        return vkDevExt146;
    case 147:
        return vkDevExt147;
    case 148:
        return vkDevExt148;
    case 149:
        return vkDevExt149;
    case 150:
        return vkDevExt150;
    case 151:
        return vkDevExt151;
    case 152:
        return vkDevExt152;
    case 153:
        return vkDevExt153;
    case 154:
        return vkDevExt154;
    case 155:
        return vkDevExt155;
    case 156:
        return vkDevExt156;
    case 157:
        return vkDevExt157;
    case 158:
        return vkDevExt158;
    case 159:
        return vkDevExt159;
    case 160:
        return vkDevExt160;
    case 161:
        return vkDevExt161;
    case 162:
        return vkDevExt162;
    case 163:
        return vkDevExt163;
    case 164:
        return vkDevExt164;
    case 165:
        return vkDevExt165;
    case 166:
        return vkDevExt166;
    case 167:
        return vkDevExt167;
    case 168:
        return vkDevExt168;
    case 169:
        return vkDevExt169;
    case 170:
        return vkDevExt170;
    case 171:
        return vkDevExt171;
    case 172:
        return vkDevExt172;
    case 173:
        return vkDevExt173;
    case 174:
        return vkDevExt174;
    case 175:
        return vkDevExt175;
    case 176:
        return vkDevExt176;
    case 177:
        return vkDevExt177;
    case 178:
        return vkDevExt178;
    case 179:
        return vkDevExt179;
    case 180:
        return vkDevExt180;
    case 181:
        return vkDevExt181;
    case 182:
        return vkDevExt182;
    case 183:
        return vkDevExt183;
    case 184:
        return vkDevExt184;
    case 185:
        return vkDevExt185;
    case 186:
        return vkDevExt186;
    case 187:
        return vkDevExt187;
    case 188:
        return vkDevExt188;
    case 189:
        return vkDevExt189;
    case 190:
        return vkDevExt190;
    case 191:
        return vkDevExt191;
    case 192:
        return vkDevExt192;
    case 193:
        return vkDevExt193;
    case 194:
        return vkDevExt194;
    case 195:
        return vkDevExt195;
    case 196:
        return vkDevExt196;
    case 197:
        return vkDevExt197;
    case 198:
        return vkDevExt198;
    case 199:
        return vkDevExt199;
    case 200:
        return vkDevExt200;
    case 201:
        return vkDevExt201;
    case 202:
        return vkDevExt202;
    case 203:
        return vkDevExt203;
    case 204:
        return vkDevExt204;
    case 205:
        return vkDevExt205;
    case 206:
        return vkDevExt206;
    case 207:
        return vkDevExt207;
    case 208:
        return vkDevExt208;
    case 209:
        return vkDevExt209;
    case 210:
        return vkDevExt210;
    case 211:
        return vkDevExt211;
    case 212:
        return vkDevExt212;
    case 213:
        return vkDevExt213;
    case 214:
        return vkDevExt214;
    case 215:
        return vkDevExt215;
    case 216:
        return vkDevExt216;
    case 217:
        return vkDevExt217;
    case 218:
        return vkDevExt218;
    case 219:
        return vkDevExt219;
    case 220:
        return vkDevExt220;
    case 221:
        return vkDevExt221;
    case 222:
        return vkDevExt222;
    case 223:
        return vkDevExt223;
    case 224:
        return vkDevExt224;
    case 225:
        return vkDevExt225;
    case 226:
        return vkDevExt226;
    case 227:
        return vkDevExt227;
    case 228:
        return vkDevExt228;
    case 229:
        return vkDevExt229;
    case 230:
        return vkDevExt230;
    case 231:
        return vkDevExt231;
    case 232:
        return vkDevExt232;
    case 233:
        return vkDevExt233;
    case 234:
        return vkDevExt234;
    case 235:
        return vkDevExt235;
    case 236:
        return vkDevExt236;
    case 237:
        return vkDevExt237;
    case 238:
        return vkDevExt238;
    case 239:
        return vkDevExt239;
    case 240:
        return vkDevExt240;
    case 241:
        return vkDevExt241;
    case 242:
        return vkDevExt242;
    case 243:
        return vkDevExt243;
    case 244:
        return vkDevExt244;
    case 245:
        return vkDevExt245;
    case 246:
        return vkDevExt246;
    case 247:
        return vkDevExt247;
    case 248:
        return vkDevExt248;
    case 249:
        return vkDevExt249;
    }
    return NULL;
}