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 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 * Author: Jon Ashburn <jon (at) lunarg.com> 19 */ 20 21 #include "vk_loader_platform.h" 22 #include "loader.h" 23 #if defined(__linux__) 24 #pragma GCC optimize(3) // force gcc to use tail-calls 25 #endif 26 27 VKAPI_ATTR void VKAPI_CALL vkdev_ext0(VkDevice device) { 28 const struct loader_dev_dispatch_table *disp; 29 disp = loader_get_dev_dispatch(device); 30 disp->ext_dispatch.dev_ext[0](device); 31 } 32 33 VKAPI_ATTR void VKAPI_CALL vkdev_ext1(VkDevice device) { 34 const struct loader_dev_dispatch_table *disp; 35 disp = loader_get_dev_dispatch(device); 36 disp->ext_dispatch.dev_ext[1](device); 37 } 38 39 VKAPI_ATTR void VKAPI_CALL vkdev_ext2(VkDevice device) { 40 const struct loader_dev_dispatch_table *disp; 41 disp = loader_get_dev_dispatch(device); 42 disp->ext_dispatch.dev_ext[2](device); 43 } 44 45 VKAPI_ATTR void VKAPI_CALL vkdev_ext3(VkDevice device) { 46 const struct loader_dev_dispatch_table *disp; 47 disp = loader_get_dev_dispatch(device); 48 disp->ext_dispatch.dev_ext[3](device); 49 } 50 51 VKAPI_ATTR void VKAPI_CALL vkdev_ext4(VkDevice device) { 52 const struct loader_dev_dispatch_table *disp; 53 disp = loader_get_dev_dispatch(device); 54 disp->ext_dispatch.dev_ext[4](device); 55 } 56 57 VKAPI_ATTR void VKAPI_CALL vkdev_ext5(VkDevice device) { 58 const struct loader_dev_dispatch_table *disp; 59 disp = loader_get_dev_dispatch(device); 60 disp->ext_dispatch.dev_ext[5](device); 61 } 62 63 VKAPI_ATTR void VKAPI_CALL vkdev_ext6(VkDevice device) { 64 const struct loader_dev_dispatch_table *disp; 65 disp = loader_get_dev_dispatch(device); 66 disp->ext_dispatch.dev_ext[6](device); 67 } 68 69 VKAPI_ATTR void VKAPI_CALL vkdev_ext7(VkDevice device) { 70 const struct loader_dev_dispatch_table *disp; 71 disp = loader_get_dev_dispatch(device); 72 disp->ext_dispatch.dev_ext[7](device); 73 } 74 75 VKAPI_ATTR void VKAPI_CALL vkdev_ext8(VkDevice device) { 76 const struct loader_dev_dispatch_table *disp; 77 disp = loader_get_dev_dispatch(device); 78 disp->ext_dispatch.dev_ext[8](device); 79 } 80 81 VKAPI_ATTR void VKAPI_CALL vkdev_ext9(VkDevice device) { 82 const struct loader_dev_dispatch_table *disp; 83 disp = loader_get_dev_dispatch(device); 84 disp->ext_dispatch.dev_ext[9](device); 85 } 86 87 VKAPI_ATTR void VKAPI_CALL vkdev_ext10(VkDevice device) { 88 const struct loader_dev_dispatch_table *disp; 89 disp = loader_get_dev_dispatch(device); 90 disp->ext_dispatch.dev_ext[10](device); 91 } 92 93 VKAPI_ATTR void VKAPI_CALL vkdev_ext11(VkDevice device) { 94 const struct loader_dev_dispatch_table *disp; 95 disp = loader_get_dev_dispatch(device); 96 disp->ext_dispatch.dev_ext[11](device); 97 } 98 99 VKAPI_ATTR void VKAPI_CALL vkdev_ext12(VkDevice device) { 100 const struct loader_dev_dispatch_table *disp; 101 disp = loader_get_dev_dispatch(device); 102 disp->ext_dispatch.dev_ext[12](device); 103 } 104 105 VKAPI_ATTR void VKAPI_CALL vkdev_ext13(VkDevice device) { 106 const struct loader_dev_dispatch_table *disp; 107 disp = loader_get_dev_dispatch(device); 108 disp->ext_dispatch.dev_ext[13](device); 109 } 110 111 VKAPI_ATTR void VKAPI_CALL vkdev_ext14(VkDevice device) { 112 const struct loader_dev_dispatch_table *disp; 113 disp = loader_get_dev_dispatch(device); 114 disp->ext_dispatch.dev_ext[14](device); 115 } 116 117 VKAPI_ATTR void VKAPI_CALL vkdev_ext15(VkDevice device) { 118 const struct loader_dev_dispatch_table *disp; 119 disp = loader_get_dev_dispatch(device); 120 disp->ext_dispatch.dev_ext[15](device); 121 } 122 123 VKAPI_ATTR void VKAPI_CALL vkdev_ext16(VkDevice device) { 124 const struct loader_dev_dispatch_table *disp; 125 disp = loader_get_dev_dispatch(device); 126 disp->ext_dispatch.dev_ext[16](device); 127 } 128 129 VKAPI_ATTR void VKAPI_CALL vkdev_ext17(VkDevice device) { 130 const struct loader_dev_dispatch_table *disp; 131 disp = loader_get_dev_dispatch(device); 132 disp->ext_dispatch.dev_ext[17](device); 133 } 134 135 VKAPI_ATTR void VKAPI_CALL vkdev_ext18(VkDevice device) { 136 const struct loader_dev_dispatch_table *disp; 137 disp = loader_get_dev_dispatch(device); 138 disp->ext_dispatch.dev_ext[18](device); 139 } 140 141 VKAPI_ATTR void VKAPI_CALL vkdev_ext19(VkDevice device) { 142 const struct loader_dev_dispatch_table *disp; 143 disp = loader_get_dev_dispatch(device); 144 disp->ext_dispatch.dev_ext[19](device); 145 } 146 147 VKAPI_ATTR void VKAPI_CALL vkdev_ext20(VkDevice device) { 148 const struct loader_dev_dispatch_table *disp; 149 disp = loader_get_dev_dispatch(device); 150 disp->ext_dispatch.dev_ext[20](device); 151 } 152 153 VKAPI_ATTR void VKAPI_CALL vkdev_ext21(VkDevice device) { 154 const struct loader_dev_dispatch_table *disp; 155 disp = loader_get_dev_dispatch(device); 156 disp->ext_dispatch.dev_ext[21](device); 157 } 158 159 VKAPI_ATTR void VKAPI_CALL vkdev_ext22(VkDevice device) { 160 const struct loader_dev_dispatch_table *disp; 161 disp = loader_get_dev_dispatch(device); 162 disp->ext_dispatch.dev_ext[22](device); 163 } 164 165 VKAPI_ATTR void VKAPI_CALL vkdev_ext23(VkDevice device) { 166 const struct loader_dev_dispatch_table *disp; 167 disp = loader_get_dev_dispatch(device); 168 disp->ext_dispatch.dev_ext[23](device); 169 } 170 171 VKAPI_ATTR void VKAPI_CALL vkdev_ext24(VkDevice device) { 172 const struct loader_dev_dispatch_table *disp; 173 disp = loader_get_dev_dispatch(device); 174 disp->ext_dispatch.dev_ext[24](device); 175 } 176 177 VKAPI_ATTR void VKAPI_CALL vkdev_ext25(VkDevice device) { 178 const struct loader_dev_dispatch_table *disp; 179 disp = loader_get_dev_dispatch(device); 180 disp->ext_dispatch.dev_ext[25](device); 181 } 182 183 VKAPI_ATTR void VKAPI_CALL vkdev_ext26(VkDevice device) { 184 const struct loader_dev_dispatch_table *disp; 185 disp = loader_get_dev_dispatch(device); 186 disp->ext_dispatch.dev_ext[26](device); 187 } 188 189 VKAPI_ATTR void VKAPI_CALL vkdev_ext27(VkDevice device) { 190 const struct loader_dev_dispatch_table *disp; 191 disp = loader_get_dev_dispatch(device); 192 disp->ext_dispatch.dev_ext[27](device); 193 } 194 195 VKAPI_ATTR void VKAPI_CALL vkdev_ext28(VkDevice device) { 196 const struct loader_dev_dispatch_table *disp; 197 disp = loader_get_dev_dispatch(device); 198 disp->ext_dispatch.dev_ext[28](device); 199 } 200 201 VKAPI_ATTR void VKAPI_CALL vkdev_ext29(VkDevice device) { 202 const struct loader_dev_dispatch_table *disp; 203 disp = loader_get_dev_dispatch(device); 204 disp->ext_dispatch.dev_ext[29](device); 205 } 206 207 VKAPI_ATTR void VKAPI_CALL vkdev_ext30(VkDevice device) { 208 const struct loader_dev_dispatch_table *disp; 209 disp = loader_get_dev_dispatch(device); 210 disp->ext_dispatch.dev_ext[30](device); 211 } 212 213 VKAPI_ATTR void VKAPI_CALL vkdev_ext31(VkDevice device) { 214 const struct loader_dev_dispatch_table *disp; 215 disp = loader_get_dev_dispatch(device); 216 disp->ext_dispatch.dev_ext[31](device); 217 } 218 219 VKAPI_ATTR void VKAPI_CALL vkdev_ext32(VkDevice device) { 220 const struct loader_dev_dispatch_table *disp; 221 disp = loader_get_dev_dispatch(device); 222 disp->ext_dispatch.dev_ext[32](device); 223 } 224 225 VKAPI_ATTR void VKAPI_CALL vkdev_ext33(VkDevice device) { 226 const struct loader_dev_dispatch_table *disp; 227 disp = loader_get_dev_dispatch(device); 228 disp->ext_dispatch.dev_ext[33](device); 229 } 230 231 VKAPI_ATTR void VKAPI_CALL vkdev_ext34(VkDevice device) { 232 const struct loader_dev_dispatch_table *disp; 233 disp = loader_get_dev_dispatch(device); 234 disp->ext_dispatch.dev_ext[34](device); 235 } 236 237 VKAPI_ATTR void VKAPI_CALL vkdev_ext35(VkDevice device) { 238 const struct loader_dev_dispatch_table *disp; 239 disp = loader_get_dev_dispatch(device); 240 disp->ext_dispatch.dev_ext[35](device); 241 } 242 243 VKAPI_ATTR void VKAPI_CALL vkdev_ext36(VkDevice device) { 244 const struct loader_dev_dispatch_table *disp; 245 disp = loader_get_dev_dispatch(device); 246 disp->ext_dispatch.dev_ext[36](device); 247 } 248 249 VKAPI_ATTR void VKAPI_CALL vkdev_ext37(VkDevice device) { 250 const struct loader_dev_dispatch_table *disp; 251 disp = loader_get_dev_dispatch(device); 252 disp->ext_dispatch.dev_ext[37](device); 253 } 254 255 VKAPI_ATTR void VKAPI_CALL vkdev_ext38(VkDevice device) { 256 const struct loader_dev_dispatch_table *disp; 257 disp = loader_get_dev_dispatch(device); 258 disp->ext_dispatch.dev_ext[38](device); 259 } 260 261 VKAPI_ATTR void VKAPI_CALL vkdev_ext39(VkDevice device) { 262 const struct loader_dev_dispatch_table *disp; 263 disp = loader_get_dev_dispatch(device); 264 disp->ext_dispatch.dev_ext[39](device); 265 } 266 267 VKAPI_ATTR void VKAPI_CALL vkdev_ext40(VkDevice device) { 268 const struct loader_dev_dispatch_table *disp; 269 disp = loader_get_dev_dispatch(device); 270 disp->ext_dispatch.dev_ext[40](device); 271 } 272 273 VKAPI_ATTR void VKAPI_CALL vkdev_ext41(VkDevice device) { 274 const struct loader_dev_dispatch_table *disp; 275 disp = loader_get_dev_dispatch(device); 276 disp->ext_dispatch.dev_ext[41](device); 277 } 278 279 VKAPI_ATTR void VKAPI_CALL vkdev_ext42(VkDevice device) { 280 const struct loader_dev_dispatch_table *disp; 281 disp = loader_get_dev_dispatch(device); 282 disp->ext_dispatch.dev_ext[42](device); 283 } 284 285 VKAPI_ATTR void VKAPI_CALL vkdev_ext43(VkDevice device) { 286 const struct loader_dev_dispatch_table *disp; 287 disp = loader_get_dev_dispatch(device); 288 disp->ext_dispatch.dev_ext[43](device); 289 } 290 291 VKAPI_ATTR void VKAPI_CALL vkdev_ext44(VkDevice device) { 292 const struct loader_dev_dispatch_table *disp; 293 disp = loader_get_dev_dispatch(device); 294 disp->ext_dispatch.dev_ext[44](device); 295 } 296 297 VKAPI_ATTR void VKAPI_CALL vkdev_ext45(VkDevice device) { 298 const struct loader_dev_dispatch_table *disp; 299 disp = loader_get_dev_dispatch(device); 300 disp->ext_dispatch.dev_ext[45](device); 301 } 302 303 VKAPI_ATTR void VKAPI_CALL vkdev_ext46(VkDevice device) { 304 const struct loader_dev_dispatch_table *disp; 305 disp = loader_get_dev_dispatch(device); 306 disp->ext_dispatch.dev_ext[46](device); 307 } 308 309 VKAPI_ATTR void VKAPI_CALL vkdev_ext47(VkDevice device) { 310 const struct loader_dev_dispatch_table *disp; 311 disp = loader_get_dev_dispatch(device); 312 disp->ext_dispatch.dev_ext[47](device); 313 } 314 315 VKAPI_ATTR void VKAPI_CALL vkdev_ext48(VkDevice device) { 316 const struct loader_dev_dispatch_table *disp; 317 disp = loader_get_dev_dispatch(device); 318 disp->ext_dispatch.dev_ext[48](device); 319 } 320 321 VKAPI_ATTR void VKAPI_CALL vkdev_ext49(VkDevice device) { 322 const struct loader_dev_dispatch_table *disp; 323 disp = loader_get_dev_dispatch(device); 324 disp->ext_dispatch.dev_ext[49](device); 325 } 326 327 VKAPI_ATTR void VKAPI_CALL vkdev_ext50(VkDevice device) { 328 const struct loader_dev_dispatch_table *disp; 329 disp = loader_get_dev_dispatch(device); 330 disp->ext_dispatch.dev_ext[50](device); 331 } 332 333 VKAPI_ATTR void VKAPI_CALL vkdev_ext51(VkDevice device) { 334 const struct loader_dev_dispatch_table *disp; 335 disp = loader_get_dev_dispatch(device); 336 disp->ext_dispatch.dev_ext[51](device); 337 } 338 339 VKAPI_ATTR void VKAPI_CALL vkdev_ext52(VkDevice device) { 340 const struct loader_dev_dispatch_table *disp; 341 disp = loader_get_dev_dispatch(device); 342 disp->ext_dispatch.dev_ext[52](device); 343 } 344 345 VKAPI_ATTR void VKAPI_CALL vkdev_ext53(VkDevice device) { 346 const struct loader_dev_dispatch_table *disp; 347 disp = loader_get_dev_dispatch(device); 348 disp->ext_dispatch.dev_ext[53](device); 349 } 350 351 VKAPI_ATTR void VKAPI_CALL vkdev_ext54(VkDevice device) { 352 const struct loader_dev_dispatch_table *disp; 353 disp = loader_get_dev_dispatch(device); 354 disp->ext_dispatch.dev_ext[54](device); 355 } 356 357 VKAPI_ATTR void VKAPI_CALL vkdev_ext55(VkDevice device) { 358 const struct loader_dev_dispatch_table *disp; 359 disp = loader_get_dev_dispatch(device); 360 disp->ext_dispatch.dev_ext[55](device); 361 } 362 363 VKAPI_ATTR void VKAPI_CALL vkdev_ext56(VkDevice device) { 364 const struct loader_dev_dispatch_table *disp; 365 disp = loader_get_dev_dispatch(device); 366 disp->ext_dispatch.dev_ext[56](device); 367 } 368 369 VKAPI_ATTR void VKAPI_CALL vkdev_ext57(VkDevice device) { 370 const struct loader_dev_dispatch_table *disp; 371 disp = loader_get_dev_dispatch(device); 372 disp->ext_dispatch.dev_ext[57](device); 373 } 374 375 VKAPI_ATTR void VKAPI_CALL vkdev_ext58(VkDevice device) { 376 const struct loader_dev_dispatch_table *disp; 377 disp = loader_get_dev_dispatch(device); 378 disp->ext_dispatch.dev_ext[58](device); 379 } 380 381 VKAPI_ATTR void VKAPI_CALL vkdev_ext59(VkDevice device) { 382 const struct loader_dev_dispatch_table *disp; 383 disp = loader_get_dev_dispatch(device); 384 disp->ext_dispatch.dev_ext[59](device); 385 } 386 387 VKAPI_ATTR void VKAPI_CALL vkdev_ext60(VkDevice device) { 388 const struct loader_dev_dispatch_table *disp; 389 disp = loader_get_dev_dispatch(device); 390 disp->ext_dispatch.dev_ext[60](device); 391 } 392 393 VKAPI_ATTR void VKAPI_CALL vkdev_ext61(VkDevice device) { 394 const struct loader_dev_dispatch_table *disp; 395 disp = loader_get_dev_dispatch(device); 396 disp->ext_dispatch.dev_ext[61](device); 397 } 398 399 VKAPI_ATTR void VKAPI_CALL vkdev_ext62(VkDevice device) { 400 const struct loader_dev_dispatch_table *disp; 401 disp = loader_get_dev_dispatch(device); 402 disp->ext_dispatch.dev_ext[62](device); 403 } 404 405 VKAPI_ATTR void VKAPI_CALL vkdev_ext63(VkDevice device) { 406 const struct loader_dev_dispatch_table *disp; 407 disp = loader_get_dev_dispatch(device); 408 disp->ext_dispatch.dev_ext[63](device); 409 } 410 411 VKAPI_ATTR void VKAPI_CALL vkdev_ext64(VkDevice device) { 412 const struct loader_dev_dispatch_table *disp; 413 disp = loader_get_dev_dispatch(device); 414 disp->ext_dispatch.dev_ext[64](device); 415 } 416 417 VKAPI_ATTR void VKAPI_CALL vkdev_ext65(VkDevice device) { 418 const struct loader_dev_dispatch_table *disp; 419 disp = loader_get_dev_dispatch(device); 420 disp->ext_dispatch.dev_ext[65](device); 421 } 422 423 VKAPI_ATTR void VKAPI_CALL vkdev_ext66(VkDevice device) { 424 const struct loader_dev_dispatch_table *disp; 425 disp = loader_get_dev_dispatch(device); 426 disp->ext_dispatch.dev_ext[66](device); 427 } 428 429 VKAPI_ATTR void VKAPI_CALL vkdev_ext67(VkDevice device) { 430 const struct loader_dev_dispatch_table *disp; 431 disp = loader_get_dev_dispatch(device); 432 disp->ext_dispatch.dev_ext[67](device); 433 } 434 435 VKAPI_ATTR void VKAPI_CALL vkdev_ext68(VkDevice device) { 436 const struct loader_dev_dispatch_table *disp; 437 disp = loader_get_dev_dispatch(device); 438 disp->ext_dispatch.dev_ext[68](device); 439 } 440 441 VKAPI_ATTR void VKAPI_CALL vkdev_ext69(VkDevice device) { 442 const struct loader_dev_dispatch_table *disp; 443 disp = loader_get_dev_dispatch(device); 444 disp->ext_dispatch.dev_ext[69](device); 445 } 446 447 VKAPI_ATTR void VKAPI_CALL vkdev_ext70(VkDevice device) { 448 const struct loader_dev_dispatch_table *disp; 449 disp = loader_get_dev_dispatch(device); 450 disp->ext_dispatch.dev_ext[70](device); 451 } 452 453 VKAPI_ATTR void VKAPI_CALL vkdev_ext71(VkDevice device) { 454 const struct loader_dev_dispatch_table *disp; 455 disp = loader_get_dev_dispatch(device); 456 disp->ext_dispatch.dev_ext[71](device); 457 } 458 459 VKAPI_ATTR void VKAPI_CALL vkdev_ext72(VkDevice device) { 460 const struct loader_dev_dispatch_table *disp; 461 disp = loader_get_dev_dispatch(device); 462 disp->ext_dispatch.dev_ext[72](device); 463 } 464 465 VKAPI_ATTR void VKAPI_CALL vkdev_ext73(VkDevice device) { 466 const struct loader_dev_dispatch_table *disp; 467 disp = loader_get_dev_dispatch(device); 468 disp->ext_dispatch.dev_ext[73](device); 469 } 470 471 VKAPI_ATTR void VKAPI_CALL vkdev_ext74(VkDevice device) { 472 const struct loader_dev_dispatch_table *disp; 473 disp = loader_get_dev_dispatch(device); 474 disp->ext_dispatch.dev_ext[74](device); 475 } 476 477 VKAPI_ATTR void VKAPI_CALL vkdev_ext75(VkDevice device) { 478 const struct loader_dev_dispatch_table *disp; 479 disp = loader_get_dev_dispatch(device); 480 disp->ext_dispatch.dev_ext[75](device); 481 } 482 483 VKAPI_ATTR void VKAPI_CALL vkdev_ext76(VkDevice device) { 484 const struct loader_dev_dispatch_table *disp; 485 disp = loader_get_dev_dispatch(device); 486 disp->ext_dispatch.dev_ext[76](device); 487 } 488 489 VKAPI_ATTR void VKAPI_CALL vkdev_ext77(VkDevice device) { 490 const struct loader_dev_dispatch_table *disp; 491 disp = loader_get_dev_dispatch(device); 492 disp->ext_dispatch.dev_ext[77](device); 493 } 494 495 VKAPI_ATTR void VKAPI_CALL vkdev_ext78(VkDevice device) { 496 const struct loader_dev_dispatch_table *disp; 497 disp = loader_get_dev_dispatch(device); 498 disp->ext_dispatch.dev_ext[78](device); 499 } 500 501 VKAPI_ATTR void VKAPI_CALL vkdev_ext79(VkDevice device) { 502 const struct loader_dev_dispatch_table *disp; 503 disp = loader_get_dev_dispatch(device); 504 disp->ext_dispatch.dev_ext[79](device); 505 } 506 507 VKAPI_ATTR void VKAPI_CALL vkdev_ext80(VkDevice device) { 508 const struct loader_dev_dispatch_table *disp; 509 disp = loader_get_dev_dispatch(device); 510 disp->ext_dispatch.dev_ext[80](device); 511 } 512 513 VKAPI_ATTR void VKAPI_CALL vkdev_ext81(VkDevice device) { 514 const struct loader_dev_dispatch_table *disp; 515 disp = loader_get_dev_dispatch(device); 516 disp->ext_dispatch.dev_ext[81](device); 517 } 518 519 VKAPI_ATTR void VKAPI_CALL vkdev_ext82(VkDevice device) { 520 const struct loader_dev_dispatch_table *disp; 521 disp = loader_get_dev_dispatch(device); 522 disp->ext_dispatch.dev_ext[82](device); 523 } 524 525 VKAPI_ATTR void VKAPI_CALL vkdev_ext83(VkDevice device) { 526 const struct loader_dev_dispatch_table *disp; 527 disp = loader_get_dev_dispatch(device); 528 disp->ext_dispatch.dev_ext[83](device); 529 } 530 531 VKAPI_ATTR void VKAPI_CALL vkdev_ext84(VkDevice device) { 532 const struct loader_dev_dispatch_table *disp; 533 disp = loader_get_dev_dispatch(device); 534 disp->ext_dispatch.dev_ext[84](device); 535 } 536 537 VKAPI_ATTR void VKAPI_CALL vkdev_ext85(VkDevice device) { 538 const struct loader_dev_dispatch_table *disp; 539 disp = loader_get_dev_dispatch(device); 540 disp->ext_dispatch.dev_ext[85](device); 541 } 542 543 VKAPI_ATTR void VKAPI_CALL vkdev_ext86(VkDevice device) { 544 const struct loader_dev_dispatch_table *disp; 545 disp = loader_get_dev_dispatch(device); 546 disp->ext_dispatch.dev_ext[86](device); 547 } 548 549 VKAPI_ATTR void VKAPI_CALL vkdev_ext87(VkDevice device) { 550 const struct loader_dev_dispatch_table *disp; 551 disp = loader_get_dev_dispatch(device); 552 disp->ext_dispatch.dev_ext[87](device); 553 } 554 555 VKAPI_ATTR void VKAPI_CALL vkdev_ext88(VkDevice device) { 556 const struct loader_dev_dispatch_table *disp; 557 disp = loader_get_dev_dispatch(device); 558 disp->ext_dispatch.dev_ext[88](device); 559 } 560 561 VKAPI_ATTR void VKAPI_CALL vkdev_ext89(VkDevice device) { 562 const struct loader_dev_dispatch_table *disp; 563 disp = loader_get_dev_dispatch(device); 564 disp->ext_dispatch.dev_ext[89](device); 565 } 566 567 VKAPI_ATTR void VKAPI_CALL vkdev_ext90(VkDevice device) { 568 const struct loader_dev_dispatch_table *disp; 569 disp = loader_get_dev_dispatch(device); 570 disp->ext_dispatch.dev_ext[90](device); 571 } 572 573 VKAPI_ATTR void VKAPI_CALL vkdev_ext91(VkDevice device) { 574 const struct loader_dev_dispatch_table *disp; 575 disp = loader_get_dev_dispatch(device); 576 disp->ext_dispatch.dev_ext[91](device); 577 } 578 579 VKAPI_ATTR void VKAPI_CALL vkdev_ext92(VkDevice device) { 580 const struct loader_dev_dispatch_table *disp; 581 disp = loader_get_dev_dispatch(device); 582 disp->ext_dispatch.dev_ext[92](device); 583 } 584 585 VKAPI_ATTR void VKAPI_CALL vkdev_ext93(VkDevice device) { 586 const struct loader_dev_dispatch_table *disp; 587 disp = loader_get_dev_dispatch(device); 588 disp->ext_dispatch.dev_ext[93](device); 589 } 590 591 VKAPI_ATTR void VKAPI_CALL vkdev_ext94(VkDevice device) { 592 const struct loader_dev_dispatch_table *disp; 593 disp = loader_get_dev_dispatch(device); 594 disp->ext_dispatch.dev_ext[94](device); 595 } 596 597 VKAPI_ATTR void VKAPI_CALL vkdev_ext95(VkDevice device) { 598 const struct loader_dev_dispatch_table *disp; 599 disp = loader_get_dev_dispatch(device); 600 disp->ext_dispatch.dev_ext[95](device); 601 } 602 603 VKAPI_ATTR void VKAPI_CALL vkdev_ext96(VkDevice device) { 604 const struct loader_dev_dispatch_table *disp; 605 disp = loader_get_dev_dispatch(device); 606 disp->ext_dispatch.dev_ext[96](device); 607 } 608 609 VKAPI_ATTR void VKAPI_CALL vkdev_ext97(VkDevice device) { 610 const struct loader_dev_dispatch_table *disp; 611 disp = loader_get_dev_dispatch(device); 612 disp->ext_dispatch.dev_ext[97](device); 613 } 614 615 VKAPI_ATTR void VKAPI_CALL vkdev_ext98(VkDevice device) { 616 const struct loader_dev_dispatch_table *disp; 617 disp = loader_get_dev_dispatch(device); 618 disp->ext_dispatch.dev_ext[98](device); 619 } 620 621 VKAPI_ATTR void VKAPI_CALL vkdev_ext99(VkDevice device) { 622 const struct loader_dev_dispatch_table *disp; 623 disp = loader_get_dev_dispatch(device); 624 disp->ext_dispatch.dev_ext[99](device); 625 } 626 627 VKAPI_ATTR void VKAPI_CALL vkdev_ext100(VkDevice device) { 628 const struct loader_dev_dispatch_table *disp; 629 disp = loader_get_dev_dispatch(device); 630 disp->ext_dispatch.dev_ext[100](device); 631 } 632 633 VKAPI_ATTR void VKAPI_CALL vkdev_ext101(VkDevice device) { 634 const struct loader_dev_dispatch_table *disp; 635 disp = loader_get_dev_dispatch(device); 636 disp->ext_dispatch.dev_ext[101](device); 637 } 638 639 VKAPI_ATTR void VKAPI_CALL vkdev_ext102(VkDevice device) { 640 const struct loader_dev_dispatch_table *disp; 641 disp = loader_get_dev_dispatch(device); 642 disp->ext_dispatch.dev_ext[102](device); 643 } 644 645 VKAPI_ATTR void VKAPI_CALL vkdev_ext103(VkDevice device) { 646 const struct loader_dev_dispatch_table *disp; 647 disp = loader_get_dev_dispatch(device); 648 disp->ext_dispatch.dev_ext[103](device); 649 } 650 651 VKAPI_ATTR void VKAPI_CALL vkdev_ext104(VkDevice device) { 652 const struct loader_dev_dispatch_table *disp; 653 disp = loader_get_dev_dispatch(device); 654 disp->ext_dispatch.dev_ext[104](device); 655 } 656 657 VKAPI_ATTR void VKAPI_CALL vkdev_ext105(VkDevice device) { 658 const struct loader_dev_dispatch_table *disp; 659 disp = loader_get_dev_dispatch(device); 660 disp->ext_dispatch.dev_ext[105](device); 661 } 662 663 VKAPI_ATTR void VKAPI_CALL vkdev_ext106(VkDevice device) { 664 const struct loader_dev_dispatch_table *disp; 665 disp = loader_get_dev_dispatch(device); 666 disp->ext_dispatch.dev_ext[106](device); 667 } 668 669 VKAPI_ATTR void VKAPI_CALL vkdev_ext107(VkDevice device) { 670 const struct loader_dev_dispatch_table *disp; 671 disp = loader_get_dev_dispatch(device); 672 disp->ext_dispatch.dev_ext[107](device); 673 } 674 675 VKAPI_ATTR void VKAPI_CALL vkdev_ext108(VkDevice device) { 676 const struct loader_dev_dispatch_table *disp; 677 disp = loader_get_dev_dispatch(device); 678 disp->ext_dispatch.dev_ext[108](device); 679 } 680 681 VKAPI_ATTR void VKAPI_CALL vkdev_ext109(VkDevice device) { 682 const struct loader_dev_dispatch_table *disp; 683 disp = loader_get_dev_dispatch(device); 684 disp->ext_dispatch.dev_ext[109](device); 685 } 686 687 VKAPI_ATTR void VKAPI_CALL vkdev_ext110(VkDevice device) { 688 const struct loader_dev_dispatch_table *disp; 689 disp = loader_get_dev_dispatch(device); 690 disp->ext_dispatch.dev_ext[110](device); 691 } 692 693 VKAPI_ATTR void VKAPI_CALL vkdev_ext111(VkDevice device) { 694 const struct loader_dev_dispatch_table *disp; 695 disp = loader_get_dev_dispatch(device); 696 disp->ext_dispatch.dev_ext[111](device); 697 } 698 699 VKAPI_ATTR void VKAPI_CALL vkdev_ext112(VkDevice device) { 700 const struct loader_dev_dispatch_table *disp; 701 disp = loader_get_dev_dispatch(device); 702 disp->ext_dispatch.dev_ext[112](device); 703 } 704 705 VKAPI_ATTR void VKAPI_CALL vkdev_ext113(VkDevice device) { 706 const struct loader_dev_dispatch_table *disp; 707 disp = loader_get_dev_dispatch(device); 708 disp->ext_dispatch.dev_ext[113](device); 709 } 710 711 VKAPI_ATTR void VKAPI_CALL vkdev_ext114(VkDevice device) { 712 const struct loader_dev_dispatch_table *disp; 713 disp = loader_get_dev_dispatch(device); 714 disp->ext_dispatch.dev_ext[114](device); 715 } 716 717 VKAPI_ATTR void VKAPI_CALL vkdev_ext115(VkDevice device) { 718 const struct loader_dev_dispatch_table *disp; 719 disp = loader_get_dev_dispatch(device); 720 disp->ext_dispatch.dev_ext[115](device); 721 } 722 723 VKAPI_ATTR void VKAPI_CALL vkdev_ext116(VkDevice device) { 724 const struct loader_dev_dispatch_table *disp; 725 disp = loader_get_dev_dispatch(device); 726 disp->ext_dispatch.dev_ext[116](device); 727 } 728 729 VKAPI_ATTR void VKAPI_CALL vkdev_ext117(VkDevice device) { 730 const struct loader_dev_dispatch_table *disp; 731 disp = loader_get_dev_dispatch(device); 732 disp->ext_dispatch.dev_ext[117](device); 733 } 734 735 VKAPI_ATTR void VKAPI_CALL vkdev_ext118(VkDevice device) { 736 const struct loader_dev_dispatch_table *disp; 737 disp = loader_get_dev_dispatch(device); 738 disp->ext_dispatch.dev_ext[118](device); 739 } 740 741 VKAPI_ATTR void VKAPI_CALL vkdev_ext119(VkDevice device) { 742 const struct loader_dev_dispatch_table *disp; 743 disp = loader_get_dev_dispatch(device); 744 disp->ext_dispatch.dev_ext[119](device); 745 } 746 747 VKAPI_ATTR void VKAPI_CALL vkdev_ext120(VkDevice device) { 748 const struct loader_dev_dispatch_table *disp; 749 disp = loader_get_dev_dispatch(device); 750 disp->ext_dispatch.dev_ext[120](device); 751 } 752 753 VKAPI_ATTR void VKAPI_CALL vkdev_ext121(VkDevice device) { 754 const struct loader_dev_dispatch_table *disp; 755 disp = loader_get_dev_dispatch(device); 756 disp->ext_dispatch.dev_ext[121](device); 757 } 758 759 VKAPI_ATTR void VKAPI_CALL vkdev_ext122(VkDevice device) { 760 const struct loader_dev_dispatch_table *disp; 761 disp = loader_get_dev_dispatch(device); 762 disp->ext_dispatch.dev_ext[122](device); 763 } 764 765 VKAPI_ATTR void VKAPI_CALL vkdev_ext123(VkDevice device) { 766 const struct loader_dev_dispatch_table *disp; 767 disp = loader_get_dev_dispatch(device); 768 disp->ext_dispatch.dev_ext[123](device); 769 } 770 771 VKAPI_ATTR void VKAPI_CALL vkdev_ext124(VkDevice device) { 772 const struct loader_dev_dispatch_table *disp; 773 disp = loader_get_dev_dispatch(device); 774 disp->ext_dispatch.dev_ext[124](device); 775 } 776 777 VKAPI_ATTR void VKAPI_CALL vkdev_ext125(VkDevice device) { 778 const struct loader_dev_dispatch_table *disp; 779 disp = loader_get_dev_dispatch(device); 780 disp->ext_dispatch.dev_ext[125](device); 781 } 782 783 VKAPI_ATTR void VKAPI_CALL vkdev_ext126(VkDevice device) { 784 const struct loader_dev_dispatch_table *disp; 785 disp = loader_get_dev_dispatch(device); 786 disp->ext_dispatch.dev_ext[126](device); 787 } 788 789 VKAPI_ATTR void VKAPI_CALL vkdev_ext127(VkDevice device) { 790 const struct loader_dev_dispatch_table *disp; 791 disp = loader_get_dev_dispatch(device); 792 disp->ext_dispatch.dev_ext[127](device); 793 } 794 795 VKAPI_ATTR void VKAPI_CALL vkdev_ext128(VkDevice device) { 796 const struct loader_dev_dispatch_table *disp; 797 disp = loader_get_dev_dispatch(device); 798 disp->ext_dispatch.dev_ext[128](device); 799 } 800 801 VKAPI_ATTR void VKAPI_CALL vkdev_ext129(VkDevice device) { 802 const struct loader_dev_dispatch_table *disp; 803 disp = loader_get_dev_dispatch(device); 804 disp->ext_dispatch.dev_ext[129](device); 805 } 806 807 VKAPI_ATTR void VKAPI_CALL vkdev_ext130(VkDevice device) { 808 const struct loader_dev_dispatch_table *disp; 809 disp = loader_get_dev_dispatch(device); 810 disp->ext_dispatch.dev_ext[130](device); 811 } 812 813 VKAPI_ATTR void VKAPI_CALL vkdev_ext131(VkDevice device) { 814 const struct loader_dev_dispatch_table *disp; 815 disp = loader_get_dev_dispatch(device); 816 disp->ext_dispatch.dev_ext[131](device); 817 } 818 819 VKAPI_ATTR void VKAPI_CALL vkdev_ext132(VkDevice device) { 820 const struct loader_dev_dispatch_table *disp; 821 disp = loader_get_dev_dispatch(device); 822 disp->ext_dispatch.dev_ext[132](device); 823 } 824 825 VKAPI_ATTR void VKAPI_CALL vkdev_ext133(VkDevice device) { 826 const struct loader_dev_dispatch_table *disp; 827 disp = loader_get_dev_dispatch(device); 828 disp->ext_dispatch.dev_ext[133](device); 829 } 830 831 VKAPI_ATTR void VKAPI_CALL vkdev_ext134(VkDevice device) { 832 const struct loader_dev_dispatch_table *disp; 833 disp = loader_get_dev_dispatch(device); 834 disp->ext_dispatch.dev_ext[134](device); 835 } 836 837 VKAPI_ATTR void VKAPI_CALL vkdev_ext135(VkDevice device) { 838 const struct loader_dev_dispatch_table *disp; 839 disp = loader_get_dev_dispatch(device); 840 disp->ext_dispatch.dev_ext[135](device); 841 } 842 843 VKAPI_ATTR void VKAPI_CALL vkdev_ext136(VkDevice device) { 844 const struct loader_dev_dispatch_table *disp; 845 disp = loader_get_dev_dispatch(device); 846 disp->ext_dispatch.dev_ext[136](device); 847 } 848 849 VKAPI_ATTR void VKAPI_CALL vkdev_ext137(VkDevice device) { 850 const struct loader_dev_dispatch_table *disp; 851 disp = loader_get_dev_dispatch(device); 852 disp->ext_dispatch.dev_ext[137](device); 853 } 854 855 VKAPI_ATTR void VKAPI_CALL vkdev_ext138(VkDevice device) { 856 const struct loader_dev_dispatch_table *disp; 857 disp = loader_get_dev_dispatch(device); 858 disp->ext_dispatch.dev_ext[138](device); 859 } 860 861 VKAPI_ATTR void VKAPI_CALL vkdev_ext139(VkDevice device) { 862 const struct loader_dev_dispatch_table *disp; 863 disp = loader_get_dev_dispatch(device); 864 disp->ext_dispatch.dev_ext[139](device); 865 } 866 867 VKAPI_ATTR void VKAPI_CALL vkdev_ext140(VkDevice device) { 868 const struct loader_dev_dispatch_table *disp; 869 disp = loader_get_dev_dispatch(device); 870 disp->ext_dispatch.dev_ext[140](device); 871 } 872 873 VKAPI_ATTR void VKAPI_CALL vkdev_ext141(VkDevice device) { 874 const struct loader_dev_dispatch_table *disp; 875 disp = loader_get_dev_dispatch(device); 876 disp->ext_dispatch.dev_ext[141](device); 877 } 878 879 VKAPI_ATTR void VKAPI_CALL vkdev_ext142(VkDevice device) { 880 const struct loader_dev_dispatch_table *disp; 881 disp = loader_get_dev_dispatch(device); 882 disp->ext_dispatch.dev_ext[142](device); 883 } 884 885 VKAPI_ATTR void VKAPI_CALL vkdev_ext143(VkDevice device) { 886 const struct loader_dev_dispatch_table *disp; 887 disp = loader_get_dev_dispatch(device); 888 disp->ext_dispatch.dev_ext[143](device); 889 } 890 891 VKAPI_ATTR void VKAPI_CALL vkdev_ext144(VkDevice device) { 892 const struct loader_dev_dispatch_table *disp; 893 disp = loader_get_dev_dispatch(device); 894 disp->ext_dispatch.dev_ext[144](device); 895 } 896 897 VKAPI_ATTR void VKAPI_CALL vkdev_ext145(VkDevice device) { 898 const struct loader_dev_dispatch_table *disp; 899 disp = loader_get_dev_dispatch(device); 900 disp->ext_dispatch.dev_ext[145](device); 901 } 902 903 VKAPI_ATTR void VKAPI_CALL vkdev_ext146(VkDevice device) { 904 const struct loader_dev_dispatch_table *disp; 905 disp = loader_get_dev_dispatch(device); 906 disp->ext_dispatch.dev_ext[146](device); 907 } 908 909 VKAPI_ATTR void VKAPI_CALL vkdev_ext147(VkDevice device) { 910 const struct loader_dev_dispatch_table *disp; 911 disp = loader_get_dev_dispatch(device); 912 disp->ext_dispatch.dev_ext[147](device); 913 } 914 915 VKAPI_ATTR void VKAPI_CALL vkdev_ext148(VkDevice device) { 916 const struct loader_dev_dispatch_table *disp; 917 disp = loader_get_dev_dispatch(device); 918 disp->ext_dispatch.dev_ext[148](device); 919 } 920 921 VKAPI_ATTR void VKAPI_CALL vkdev_ext149(VkDevice device) { 922 const struct loader_dev_dispatch_table *disp; 923 disp = loader_get_dev_dispatch(device); 924 disp->ext_dispatch.dev_ext[149](device); 925 } 926 927 VKAPI_ATTR void VKAPI_CALL vkdev_ext150(VkDevice device) { 928 const struct loader_dev_dispatch_table *disp; 929 disp = loader_get_dev_dispatch(device); 930 disp->ext_dispatch.dev_ext[150](device); 931 } 932 933 VKAPI_ATTR void VKAPI_CALL vkdev_ext151(VkDevice device) { 934 const struct loader_dev_dispatch_table *disp; 935 disp = loader_get_dev_dispatch(device); 936 disp->ext_dispatch.dev_ext[151](device); 937 } 938 939 VKAPI_ATTR void VKAPI_CALL vkdev_ext152(VkDevice device) { 940 const struct loader_dev_dispatch_table *disp; 941 disp = loader_get_dev_dispatch(device); 942 disp->ext_dispatch.dev_ext[152](device); 943 } 944 945 VKAPI_ATTR void VKAPI_CALL vkdev_ext153(VkDevice device) { 946 const struct loader_dev_dispatch_table *disp; 947 disp = loader_get_dev_dispatch(device); 948 disp->ext_dispatch.dev_ext[153](device); 949 } 950 951 VKAPI_ATTR void VKAPI_CALL vkdev_ext154(VkDevice device) { 952 const struct loader_dev_dispatch_table *disp; 953 disp = loader_get_dev_dispatch(device); 954 disp->ext_dispatch.dev_ext[154](device); 955 } 956 957 VKAPI_ATTR void VKAPI_CALL vkdev_ext155(VkDevice device) { 958 const struct loader_dev_dispatch_table *disp; 959 disp = loader_get_dev_dispatch(device); 960 disp->ext_dispatch.dev_ext[155](device); 961 } 962 963 VKAPI_ATTR void VKAPI_CALL vkdev_ext156(VkDevice device) { 964 const struct loader_dev_dispatch_table *disp; 965 disp = loader_get_dev_dispatch(device); 966 disp->ext_dispatch.dev_ext[156](device); 967 } 968 969 VKAPI_ATTR void VKAPI_CALL vkdev_ext157(VkDevice device) { 970 const struct loader_dev_dispatch_table *disp; 971 disp = loader_get_dev_dispatch(device); 972 disp->ext_dispatch.dev_ext[157](device); 973 } 974 975 VKAPI_ATTR void VKAPI_CALL vkdev_ext158(VkDevice device) { 976 const struct loader_dev_dispatch_table *disp; 977 disp = loader_get_dev_dispatch(device); 978 disp->ext_dispatch.dev_ext[158](device); 979 } 980 981 VKAPI_ATTR void VKAPI_CALL vkdev_ext159(VkDevice device) { 982 const struct loader_dev_dispatch_table *disp; 983 disp = loader_get_dev_dispatch(device); 984 disp->ext_dispatch.dev_ext[159](device); 985 } 986 987 VKAPI_ATTR void VKAPI_CALL vkdev_ext160(VkDevice device) { 988 const struct loader_dev_dispatch_table *disp; 989 disp = loader_get_dev_dispatch(device); 990 disp->ext_dispatch.dev_ext[160](device); 991 } 992 993 VKAPI_ATTR void VKAPI_CALL vkdev_ext161(VkDevice device) { 994 const struct loader_dev_dispatch_table *disp; 995 disp = loader_get_dev_dispatch(device); 996 disp->ext_dispatch.dev_ext[161](device); 997 } 998 999 VKAPI_ATTR void VKAPI_CALL vkdev_ext162(VkDevice device) { 1000 const struct loader_dev_dispatch_table *disp; 1001 disp = loader_get_dev_dispatch(device); 1002 disp->ext_dispatch.dev_ext[162](device); 1003 } 1004 1005 VKAPI_ATTR void VKAPI_CALL vkdev_ext163(VkDevice device) { 1006 const struct loader_dev_dispatch_table *disp; 1007 disp = loader_get_dev_dispatch(device); 1008 disp->ext_dispatch.dev_ext[163](device); 1009 } 1010 1011 VKAPI_ATTR void VKAPI_CALL vkdev_ext164(VkDevice device) { 1012 const struct loader_dev_dispatch_table *disp; 1013 disp = loader_get_dev_dispatch(device); 1014 disp->ext_dispatch.dev_ext[164](device); 1015 } 1016 1017 VKAPI_ATTR void VKAPI_CALL vkdev_ext165(VkDevice device) { 1018 const struct loader_dev_dispatch_table *disp; 1019 disp = loader_get_dev_dispatch(device); 1020 disp->ext_dispatch.dev_ext[165](device); 1021 } 1022 1023 VKAPI_ATTR void VKAPI_CALL vkdev_ext166(VkDevice device) { 1024 const struct loader_dev_dispatch_table *disp; 1025 disp = loader_get_dev_dispatch(device); 1026 disp->ext_dispatch.dev_ext[166](device); 1027 } 1028 1029 VKAPI_ATTR void VKAPI_CALL vkdev_ext167(VkDevice device) { 1030 const struct loader_dev_dispatch_table *disp; 1031 disp = loader_get_dev_dispatch(device); 1032 disp->ext_dispatch.dev_ext[167](device); 1033 } 1034 1035 VKAPI_ATTR void VKAPI_CALL vkdev_ext168(VkDevice device) { 1036 const struct loader_dev_dispatch_table *disp; 1037 disp = loader_get_dev_dispatch(device); 1038 disp->ext_dispatch.dev_ext[168](device); 1039 } 1040 1041 VKAPI_ATTR void VKAPI_CALL vkdev_ext169(VkDevice device) { 1042 const struct loader_dev_dispatch_table *disp; 1043 disp = loader_get_dev_dispatch(device); 1044 disp->ext_dispatch.dev_ext[169](device); 1045 } 1046 1047 VKAPI_ATTR void VKAPI_CALL vkdev_ext170(VkDevice device) { 1048 const struct loader_dev_dispatch_table *disp; 1049 disp = loader_get_dev_dispatch(device); 1050 disp->ext_dispatch.dev_ext[170](device); 1051 } 1052 1053 VKAPI_ATTR void VKAPI_CALL vkdev_ext171(VkDevice device) { 1054 const struct loader_dev_dispatch_table *disp; 1055 disp = loader_get_dev_dispatch(device); 1056 disp->ext_dispatch.dev_ext[171](device); 1057 } 1058 1059 VKAPI_ATTR void VKAPI_CALL vkdev_ext172(VkDevice device) { 1060 const struct loader_dev_dispatch_table *disp; 1061 disp = loader_get_dev_dispatch(device); 1062 disp->ext_dispatch.dev_ext[172](device); 1063 } 1064 1065 VKAPI_ATTR void VKAPI_CALL vkdev_ext173(VkDevice device) { 1066 const struct loader_dev_dispatch_table *disp; 1067 disp = loader_get_dev_dispatch(device); 1068 disp->ext_dispatch.dev_ext[173](device); 1069 } 1070 1071 VKAPI_ATTR void VKAPI_CALL vkdev_ext174(VkDevice device) { 1072 const struct loader_dev_dispatch_table *disp; 1073 disp = loader_get_dev_dispatch(device); 1074 disp->ext_dispatch.dev_ext[174](device); 1075 } 1076 1077 VKAPI_ATTR void VKAPI_CALL vkdev_ext175(VkDevice device) { 1078 const struct loader_dev_dispatch_table *disp; 1079 disp = loader_get_dev_dispatch(device); 1080 disp->ext_dispatch.dev_ext[175](device); 1081 } 1082 1083 VKAPI_ATTR void VKAPI_CALL vkdev_ext176(VkDevice device) { 1084 const struct loader_dev_dispatch_table *disp; 1085 disp = loader_get_dev_dispatch(device); 1086 disp->ext_dispatch.dev_ext[176](device); 1087 } 1088 1089 VKAPI_ATTR void VKAPI_CALL vkdev_ext177(VkDevice device) { 1090 const struct loader_dev_dispatch_table *disp; 1091 disp = loader_get_dev_dispatch(device); 1092 disp->ext_dispatch.dev_ext[177](device); 1093 } 1094 1095 VKAPI_ATTR void VKAPI_CALL vkdev_ext178(VkDevice device) { 1096 const struct loader_dev_dispatch_table *disp; 1097 disp = loader_get_dev_dispatch(device); 1098 disp->ext_dispatch.dev_ext[178](device); 1099 } 1100 1101 VKAPI_ATTR void VKAPI_CALL vkdev_ext179(VkDevice device) { 1102 const struct loader_dev_dispatch_table *disp; 1103 disp = loader_get_dev_dispatch(device); 1104 disp->ext_dispatch.dev_ext[179](device); 1105 } 1106 1107 VKAPI_ATTR void VKAPI_CALL vkdev_ext180(VkDevice device) { 1108 const struct loader_dev_dispatch_table *disp; 1109 disp = loader_get_dev_dispatch(device); 1110 disp->ext_dispatch.dev_ext[180](device); 1111 } 1112 1113 VKAPI_ATTR void VKAPI_CALL vkdev_ext181(VkDevice device) { 1114 const struct loader_dev_dispatch_table *disp; 1115 disp = loader_get_dev_dispatch(device); 1116 disp->ext_dispatch.dev_ext[181](device); 1117 } 1118 1119 VKAPI_ATTR void VKAPI_CALL vkdev_ext182(VkDevice device) { 1120 const struct loader_dev_dispatch_table *disp; 1121 disp = loader_get_dev_dispatch(device); 1122 disp->ext_dispatch.dev_ext[182](device); 1123 } 1124 1125 VKAPI_ATTR void VKAPI_CALL vkdev_ext183(VkDevice device) { 1126 const struct loader_dev_dispatch_table *disp; 1127 disp = loader_get_dev_dispatch(device); 1128 disp->ext_dispatch.dev_ext[183](device); 1129 } 1130 1131 VKAPI_ATTR void VKAPI_CALL vkdev_ext184(VkDevice device) { 1132 const struct loader_dev_dispatch_table *disp; 1133 disp = loader_get_dev_dispatch(device); 1134 disp->ext_dispatch.dev_ext[184](device); 1135 } 1136 1137 VKAPI_ATTR void VKAPI_CALL vkdev_ext185(VkDevice device) { 1138 const struct loader_dev_dispatch_table *disp; 1139 disp = loader_get_dev_dispatch(device); 1140 disp->ext_dispatch.dev_ext[185](device); 1141 } 1142 1143 VKAPI_ATTR void VKAPI_CALL vkdev_ext186(VkDevice device) { 1144 const struct loader_dev_dispatch_table *disp; 1145 disp = loader_get_dev_dispatch(device); 1146 disp->ext_dispatch.dev_ext[186](device); 1147 } 1148 1149 VKAPI_ATTR void VKAPI_CALL vkdev_ext187(VkDevice device) { 1150 const struct loader_dev_dispatch_table *disp; 1151 disp = loader_get_dev_dispatch(device); 1152 disp->ext_dispatch.dev_ext[187](device); 1153 } 1154 1155 VKAPI_ATTR void VKAPI_CALL vkdev_ext188(VkDevice device) { 1156 const struct loader_dev_dispatch_table *disp; 1157 disp = loader_get_dev_dispatch(device); 1158 disp->ext_dispatch.dev_ext[188](device); 1159 } 1160 1161 VKAPI_ATTR void VKAPI_CALL vkdev_ext189(VkDevice device) { 1162 const struct loader_dev_dispatch_table *disp; 1163 disp = loader_get_dev_dispatch(device); 1164 disp->ext_dispatch.dev_ext[189](device); 1165 } 1166 1167 VKAPI_ATTR void VKAPI_CALL vkdev_ext190(VkDevice device) { 1168 const struct loader_dev_dispatch_table *disp; 1169 disp = loader_get_dev_dispatch(device); 1170 disp->ext_dispatch.dev_ext[190](device); 1171 } 1172 1173 VKAPI_ATTR void VKAPI_CALL vkdev_ext191(VkDevice device) { 1174 const struct loader_dev_dispatch_table *disp; 1175 disp = loader_get_dev_dispatch(device); 1176 disp->ext_dispatch.dev_ext[191](device); 1177 } 1178 1179 VKAPI_ATTR void VKAPI_CALL vkdev_ext192(VkDevice device) { 1180 const struct loader_dev_dispatch_table *disp; 1181 disp = loader_get_dev_dispatch(device); 1182 disp->ext_dispatch.dev_ext[192](device); 1183 } 1184 1185 VKAPI_ATTR void VKAPI_CALL vkdev_ext193(VkDevice device) { 1186 const struct loader_dev_dispatch_table *disp; 1187 disp = loader_get_dev_dispatch(device); 1188 disp->ext_dispatch.dev_ext[193](device); 1189 } 1190 1191 VKAPI_ATTR void VKAPI_CALL vkdev_ext194(VkDevice device) { 1192 const struct loader_dev_dispatch_table *disp; 1193 disp = loader_get_dev_dispatch(device); 1194 disp->ext_dispatch.dev_ext[194](device); 1195 } 1196 1197 VKAPI_ATTR void VKAPI_CALL vkdev_ext195(VkDevice device) { 1198 const struct loader_dev_dispatch_table *disp; 1199 disp = loader_get_dev_dispatch(device); 1200 disp->ext_dispatch.dev_ext[195](device); 1201 } 1202 1203 VKAPI_ATTR void VKAPI_CALL vkdev_ext196(VkDevice device) { 1204 const struct loader_dev_dispatch_table *disp; 1205 disp = loader_get_dev_dispatch(device); 1206 disp->ext_dispatch.dev_ext[196](device); 1207 } 1208 1209 VKAPI_ATTR void VKAPI_CALL vkdev_ext197(VkDevice device) { 1210 const struct loader_dev_dispatch_table *disp; 1211 disp = loader_get_dev_dispatch(device); 1212 disp->ext_dispatch.dev_ext[197](device); 1213 } 1214 1215 VKAPI_ATTR void VKAPI_CALL vkdev_ext198(VkDevice device) { 1216 const struct loader_dev_dispatch_table *disp; 1217 disp = loader_get_dev_dispatch(device); 1218 disp->ext_dispatch.dev_ext[198](device); 1219 } 1220 1221 VKAPI_ATTR void VKAPI_CALL vkdev_ext199(VkDevice device) { 1222 const struct loader_dev_dispatch_table *disp; 1223 disp = loader_get_dev_dispatch(device); 1224 disp->ext_dispatch.dev_ext[199](device); 1225 } 1226 1227 VKAPI_ATTR void VKAPI_CALL vkdev_ext200(VkDevice device) { 1228 const struct loader_dev_dispatch_table *disp; 1229 disp = loader_get_dev_dispatch(device); 1230 disp->ext_dispatch.dev_ext[200](device); 1231 } 1232 1233 VKAPI_ATTR void VKAPI_CALL vkdev_ext201(VkDevice device) { 1234 const struct loader_dev_dispatch_table *disp; 1235 disp = loader_get_dev_dispatch(device); 1236 disp->ext_dispatch.dev_ext[201](device); 1237 } 1238 1239 VKAPI_ATTR void VKAPI_CALL vkdev_ext202(VkDevice device) { 1240 const struct loader_dev_dispatch_table *disp; 1241 disp = loader_get_dev_dispatch(device); 1242 disp->ext_dispatch.dev_ext[202](device); 1243 } 1244 1245 VKAPI_ATTR void VKAPI_CALL vkdev_ext203(VkDevice device) { 1246 const struct loader_dev_dispatch_table *disp; 1247 disp = loader_get_dev_dispatch(device); 1248 disp->ext_dispatch.dev_ext[203](device); 1249 } 1250 1251 VKAPI_ATTR void VKAPI_CALL vkdev_ext204(VkDevice device) { 1252 const struct loader_dev_dispatch_table *disp; 1253 disp = loader_get_dev_dispatch(device); 1254 disp->ext_dispatch.dev_ext[204](device); 1255 } 1256 1257 VKAPI_ATTR void VKAPI_CALL vkdev_ext205(VkDevice device) { 1258 const struct loader_dev_dispatch_table *disp; 1259 disp = loader_get_dev_dispatch(device); 1260 disp->ext_dispatch.dev_ext[205](device); 1261 } 1262 1263 VKAPI_ATTR void VKAPI_CALL vkdev_ext206(VkDevice device) { 1264 const struct loader_dev_dispatch_table *disp; 1265 disp = loader_get_dev_dispatch(device); 1266 disp->ext_dispatch.dev_ext[206](device); 1267 } 1268 1269 VKAPI_ATTR void VKAPI_CALL vkdev_ext207(VkDevice device) { 1270 const struct loader_dev_dispatch_table *disp; 1271 disp = loader_get_dev_dispatch(device); 1272 disp->ext_dispatch.dev_ext[207](device); 1273 } 1274 1275 VKAPI_ATTR void VKAPI_CALL vkdev_ext208(VkDevice device) { 1276 const struct loader_dev_dispatch_table *disp; 1277 disp = loader_get_dev_dispatch(device); 1278 disp->ext_dispatch.dev_ext[208](device); 1279 } 1280 1281 VKAPI_ATTR void VKAPI_CALL vkdev_ext209(VkDevice device) { 1282 const struct loader_dev_dispatch_table *disp; 1283 disp = loader_get_dev_dispatch(device); 1284 disp->ext_dispatch.dev_ext[209](device); 1285 } 1286 1287 VKAPI_ATTR void VKAPI_CALL vkdev_ext210(VkDevice device) { 1288 const struct loader_dev_dispatch_table *disp; 1289 disp = loader_get_dev_dispatch(device); 1290 disp->ext_dispatch.dev_ext[210](device); 1291 } 1292 1293 VKAPI_ATTR void VKAPI_CALL vkdev_ext211(VkDevice device) { 1294 const struct loader_dev_dispatch_table *disp; 1295 disp = loader_get_dev_dispatch(device); 1296 disp->ext_dispatch.dev_ext[211](device); 1297 } 1298 1299 VKAPI_ATTR void VKAPI_CALL vkdev_ext212(VkDevice device) { 1300 const struct loader_dev_dispatch_table *disp; 1301 disp = loader_get_dev_dispatch(device); 1302 disp->ext_dispatch.dev_ext[212](device); 1303 } 1304 1305 VKAPI_ATTR void VKAPI_CALL vkdev_ext213(VkDevice device) { 1306 const struct loader_dev_dispatch_table *disp; 1307 disp = loader_get_dev_dispatch(device); 1308 disp->ext_dispatch.dev_ext[213](device); 1309 } 1310 1311 VKAPI_ATTR void VKAPI_CALL vkdev_ext214(VkDevice device) { 1312 const struct loader_dev_dispatch_table *disp; 1313 disp = loader_get_dev_dispatch(device); 1314 disp->ext_dispatch.dev_ext[214](device); 1315 } 1316 1317 VKAPI_ATTR void VKAPI_CALL vkdev_ext215(VkDevice device) { 1318 const struct loader_dev_dispatch_table *disp; 1319 disp = loader_get_dev_dispatch(device); 1320 disp->ext_dispatch.dev_ext[215](device); 1321 } 1322 1323 VKAPI_ATTR void VKAPI_CALL vkdev_ext216(VkDevice device) { 1324 const struct loader_dev_dispatch_table *disp; 1325 disp = loader_get_dev_dispatch(device); 1326 disp->ext_dispatch.dev_ext[216](device); 1327 } 1328 1329 VKAPI_ATTR void VKAPI_CALL vkdev_ext217(VkDevice device) { 1330 const struct loader_dev_dispatch_table *disp; 1331 disp = loader_get_dev_dispatch(device); 1332 disp->ext_dispatch.dev_ext[217](device); 1333 } 1334 1335 VKAPI_ATTR void VKAPI_CALL vkdev_ext218(VkDevice device) { 1336 const struct loader_dev_dispatch_table *disp; 1337 disp = loader_get_dev_dispatch(device); 1338 disp->ext_dispatch.dev_ext[218](device); 1339 } 1340 1341 VKAPI_ATTR void VKAPI_CALL vkdev_ext219(VkDevice device) { 1342 const struct loader_dev_dispatch_table *disp; 1343 disp = loader_get_dev_dispatch(device); 1344 disp->ext_dispatch.dev_ext[219](device); 1345 } 1346 1347 VKAPI_ATTR void VKAPI_CALL vkdev_ext220(VkDevice device) { 1348 const struct loader_dev_dispatch_table *disp; 1349 disp = loader_get_dev_dispatch(device); 1350 disp->ext_dispatch.dev_ext[220](device); 1351 } 1352 1353 VKAPI_ATTR void VKAPI_CALL vkdev_ext221(VkDevice device) { 1354 const struct loader_dev_dispatch_table *disp; 1355 disp = loader_get_dev_dispatch(device); 1356 disp->ext_dispatch.dev_ext[221](device); 1357 } 1358 1359 VKAPI_ATTR void VKAPI_CALL vkdev_ext222(VkDevice device) { 1360 const struct loader_dev_dispatch_table *disp; 1361 disp = loader_get_dev_dispatch(device); 1362 disp->ext_dispatch.dev_ext[222](device); 1363 } 1364 1365 VKAPI_ATTR void VKAPI_CALL vkdev_ext223(VkDevice device) { 1366 const struct loader_dev_dispatch_table *disp; 1367 disp = loader_get_dev_dispatch(device); 1368 disp->ext_dispatch.dev_ext[223](device); 1369 } 1370 1371 VKAPI_ATTR void VKAPI_CALL vkdev_ext224(VkDevice device) { 1372 const struct loader_dev_dispatch_table *disp; 1373 disp = loader_get_dev_dispatch(device); 1374 disp->ext_dispatch.dev_ext[224](device); 1375 } 1376 1377 VKAPI_ATTR void VKAPI_CALL vkdev_ext225(VkDevice device) { 1378 const struct loader_dev_dispatch_table *disp; 1379 disp = loader_get_dev_dispatch(device); 1380 disp->ext_dispatch.dev_ext[225](device); 1381 } 1382 1383 VKAPI_ATTR void VKAPI_CALL vkdev_ext226(VkDevice device) { 1384 const struct loader_dev_dispatch_table *disp; 1385 disp = loader_get_dev_dispatch(device); 1386 disp->ext_dispatch.dev_ext[226](device); 1387 } 1388 1389 VKAPI_ATTR void VKAPI_CALL vkdev_ext227(VkDevice device) { 1390 const struct loader_dev_dispatch_table *disp; 1391 disp = loader_get_dev_dispatch(device); 1392 disp->ext_dispatch.dev_ext[227](device); 1393 } 1394 1395 VKAPI_ATTR void VKAPI_CALL vkdev_ext228(VkDevice device) { 1396 const struct loader_dev_dispatch_table *disp; 1397 disp = loader_get_dev_dispatch(device); 1398 disp->ext_dispatch.dev_ext[228](device); 1399 } 1400 1401 VKAPI_ATTR void VKAPI_CALL vkdev_ext229(VkDevice device) { 1402 const struct loader_dev_dispatch_table *disp; 1403 disp = loader_get_dev_dispatch(device); 1404 disp->ext_dispatch.dev_ext[229](device); 1405 } 1406 1407 VKAPI_ATTR void VKAPI_CALL vkdev_ext230(VkDevice device) { 1408 const struct loader_dev_dispatch_table *disp; 1409 disp = loader_get_dev_dispatch(device); 1410 disp->ext_dispatch.dev_ext[230](device); 1411 } 1412 1413 VKAPI_ATTR void VKAPI_CALL vkdev_ext231(VkDevice device) { 1414 const struct loader_dev_dispatch_table *disp; 1415 disp = loader_get_dev_dispatch(device); 1416 disp->ext_dispatch.dev_ext[231](device); 1417 } 1418 1419 VKAPI_ATTR void VKAPI_CALL vkdev_ext232(VkDevice device) { 1420 const struct loader_dev_dispatch_table *disp; 1421 disp = loader_get_dev_dispatch(device); 1422 disp->ext_dispatch.dev_ext[232](device); 1423 } 1424 1425 VKAPI_ATTR void VKAPI_CALL vkdev_ext233(VkDevice device) { 1426 const struct loader_dev_dispatch_table *disp; 1427 disp = loader_get_dev_dispatch(device); 1428 disp->ext_dispatch.dev_ext[233](device); 1429 } 1430 1431 VKAPI_ATTR void VKAPI_CALL vkdev_ext234(VkDevice device) { 1432 const struct loader_dev_dispatch_table *disp; 1433 disp = loader_get_dev_dispatch(device); 1434 disp->ext_dispatch.dev_ext[234](device); 1435 } 1436 1437 VKAPI_ATTR void VKAPI_CALL vkdev_ext235(VkDevice device) { 1438 const struct loader_dev_dispatch_table *disp; 1439 disp = loader_get_dev_dispatch(device); 1440 disp->ext_dispatch.dev_ext[235](device); 1441 } 1442 1443 VKAPI_ATTR void VKAPI_CALL vkdev_ext236(VkDevice device) { 1444 const struct loader_dev_dispatch_table *disp; 1445 disp = loader_get_dev_dispatch(device); 1446 disp->ext_dispatch.dev_ext[236](device); 1447 } 1448 1449 VKAPI_ATTR void VKAPI_CALL vkdev_ext237(VkDevice device) { 1450 const struct loader_dev_dispatch_table *disp; 1451 disp = loader_get_dev_dispatch(device); 1452 disp->ext_dispatch.dev_ext[237](device); 1453 } 1454 1455 VKAPI_ATTR void VKAPI_CALL vkdev_ext238(VkDevice device) { 1456 const struct loader_dev_dispatch_table *disp; 1457 disp = loader_get_dev_dispatch(device); 1458 disp->ext_dispatch.dev_ext[238](device); 1459 } 1460 1461 VKAPI_ATTR void VKAPI_CALL vkdev_ext239(VkDevice device) { 1462 const struct loader_dev_dispatch_table *disp; 1463 disp = loader_get_dev_dispatch(device); 1464 disp->ext_dispatch.dev_ext[239](device); 1465 } 1466 1467 VKAPI_ATTR void VKAPI_CALL vkdev_ext240(VkDevice device) { 1468 const struct loader_dev_dispatch_table *disp; 1469 disp = loader_get_dev_dispatch(device); 1470 disp->ext_dispatch.dev_ext[240](device); 1471 } 1472 1473 VKAPI_ATTR void VKAPI_CALL vkdev_ext241(VkDevice device) { 1474 const struct loader_dev_dispatch_table *disp; 1475 disp = loader_get_dev_dispatch(device); 1476 disp->ext_dispatch.dev_ext[241](device); 1477 } 1478 1479 VKAPI_ATTR void VKAPI_CALL vkdev_ext242(VkDevice device) { 1480 const struct loader_dev_dispatch_table *disp; 1481 disp = loader_get_dev_dispatch(device); 1482 disp->ext_dispatch.dev_ext[242](device); 1483 } 1484 1485 VKAPI_ATTR void VKAPI_CALL vkdev_ext243(VkDevice device) { 1486 const struct loader_dev_dispatch_table *disp; 1487 disp = loader_get_dev_dispatch(device); 1488 disp->ext_dispatch.dev_ext[243](device); 1489 } 1490 1491 VKAPI_ATTR void VKAPI_CALL vkdev_ext244(VkDevice device) { 1492 const struct loader_dev_dispatch_table *disp; 1493 disp = loader_get_dev_dispatch(device); 1494 disp->ext_dispatch.dev_ext[244](device); 1495 } 1496 1497 VKAPI_ATTR void VKAPI_CALL vkdev_ext245(VkDevice device) { 1498 const struct loader_dev_dispatch_table *disp; 1499 disp = loader_get_dev_dispatch(device); 1500 disp->ext_dispatch.dev_ext[245](device); 1501 } 1502 1503 VKAPI_ATTR void VKAPI_CALL vkdev_ext246(VkDevice device) { 1504 const struct loader_dev_dispatch_table *disp; 1505 disp = loader_get_dev_dispatch(device); 1506 disp->ext_dispatch.dev_ext[246](device); 1507 } 1508 1509 VKAPI_ATTR void VKAPI_CALL vkdev_ext247(VkDevice device) { 1510 const struct loader_dev_dispatch_table *disp; 1511 disp = loader_get_dev_dispatch(device); 1512 disp->ext_dispatch.dev_ext[247](device); 1513 } 1514 1515 VKAPI_ATTR void VKAPI_CALL vkdev_ext248(VkDevice device) { 1516 const struct loader_dev_dispatch_table *disp; 1517 disp = loader_get_dev_dispatch(device); 1518 disp->ext_dispatch.dev_ext[248](device); 1519 } 1520 1521 VKAPI_ATTR void VKAPI_CALL vkdev_ext249(VkDevice device) { 1522 const struct loader_dev_dispatch_table *disp; 1523 disp = loader_get_dev_dispatch(device); 1524 disp->ext_dispatch.dev_ext[249](device); 1525 } 1526 1527 void *loader_get_dev_ext_trampoline(uint32_t index) { 1528 switch (index) { 1529 case 0: 1530 return vkdev_ext0; 1531 case 1: 1532 return vkdev_ext1; 1533 case 2: 1534 return vkdev_ext2; 1535 case 3: 1536 return vkdev_ext3; 1537 case 4: 1538 return vkdev_ext4; 1539 case 5: 1540 return vkdev_ext5; 1541 case 6: 1542 return vkdev_ext6; 1543 case 7: 1544 return vkdev_ext7; 1545 case 8: 1546 return vkdev_ext8; 1547 case 9: 1548 return vkdev_ext9; 1549 case 10: 1550 return vkdev_ext10; 1551 case 11: 1552 return vkdev_ext11; 1553 case 12: 1554 return vkdev_ext12; 1555 case 13: 1556 return vkdev_ext13; 1557 case 14: 1558 return vkdev_ext14; 1559 case 15: 1560 return vkdev_ext15; 1561 case 16: 1562 return vkdev_ext16; 1563 case 17: 1564 return vkdev_ext17; 1565 case 18: 1566 return vkdev_ext18; 1567 case 19: 1568 return vkdev_ext19; 1569 case 20: 1570 return vkdev_ext20; 1571 case 21: 1572 return vkdev_ext21; 1573 case 22: 1574 return vkdev_ext22; 1575 case 23: 1576 return vkdev_ext23; 1577 case 24: 1578 return vkdev_ext24; 1579 case 25: 1580 return vkdev_ext25; 1581 case 26: 1582 return vkdev_ext26; 1583 case 27: 1584 return vkdev_ext27; 1585 case 28: 1586 return vkdev_ext28; 1587 case 29: 1588 return vkdev_ext29; 1589 case 30: 1590 return vkdev_ext30; 1591 case 31: 1592 return vkdev_ext31; 1593 case 32: 1594 return vkdev_ext32; 1595 case 33: 1596 return vkdev_ext33; 1597 case 34: 1598 return vkdev_ext34; 1599 case 35: 1600 return vkdev_ext35; 1601 case 36: 1602 return vkdev_ext36; 1603 case 37: 1604 return vkdev_ext37; 1605 case 38: 1606 return vkdev_ext38; 1607 case 39: 1608 return vkdev_ext39; 1609 case 40: 1610 return vkdev_ext40; 1611 case 41: 1612 return vkdev_ext41; 1613 case 42: 1614 return vkdev_ext42; 1615 case 43: 1616 return vkdev_ext43; 1617 case 44: 1618 return vkdev_ext44; 1619 case 45: 1620 return vkdev_ext45; 1621 case 46: 1622 return vkdev_ext46; 1623 case 47: 1624 return vkdev_ext47; 1625 case 48: 1626 return vkdev_ext48; 1627 case 49: 1628 return vkdev_ext49; 1629 case 50: 1630 return vkdev_ext50; 1631 case 51: 1632 return vkdev_ext51; 1633 case 52: 1634 return vkdev_ext52; 1635 case 53: 1636 return vkdev_ext53; 1637 case 54: 1638 return vkdev_ext54; 1639 case 55: 1640 return vkdev_ext55; 1641 case 56: 1642 return vkdev_ext56; 1643 case 57: 1644 return vkdev_ext57; 1645 case 58: 1646 return vkdev_ext58; 1647 case 59: 1648 return vkdev_ext59; 1649 case 60: 1650 return vkdev_ext60; 1651 case 61: 1652 return vkdev_ext61; 1653 case 62: 1654 return vkdev_ext62; 1655 case 63: 1656 return vkdev_ext63; 1657 case 64: 1658 return vkdev_ext64; 1659 case 65: 1660 return vkdev_ext65; 1661 case 66: 1662 return vkdev_ext66; 1663 case 67: 1664 return vkdev_ext67; 1665 case 68: 1666 return vkdev_ext68; 1667 case 69: 1668 return vkdev_ext69; 1669 case 70: 1670 return vkdev_ext70; 1671 case 71: 1672 return vkdev_ext71; 1673 case 72: 1674 return vkdev_ext72; 1675 case 73: 1676 return vkdev_ext73; 1677 case 74: 1678 return vkdev_ext74; 1679 case 75: 1680 return vkdev_ext75; 1681 case 76: 1682 return vkdev_ext76; 1683 case 77: 1684 return vkdev_ext77; 1685 case 78: 1686 return vkdev_ext78; 1687 case 79: 1688 return vkdev_ext79; 1689 case 80: 1690 return vkdev_ext80; 1691 case 81: 1692 return vkdev_ext81; 1693 case 82: 1694 return vkdev_ext82; 1695 case 83: 1696 return vkdev_ext83; 1697 case 84: 1698 return vkdev_ext84; 1699 case 85: 1700 return vkdev_ext85; 1701 case 86: 1702 return vkdev_ext86; 1703 case 87: 1704 return vkdev_ext87; 1705 case 88: 1706 return vkdev_ext88; 1707 case 89: 1708 return vkdev_ext89; 1709 case 90: 1710 return vkdev_ext90; 1711 case 91: 1712 return vkdev_ext91; 1713 case 92: 1714 return vkdev_ext92; 1715 case 93: 1716 return vkdev_ext93; 1717 case 94: 1718 return vkdev_ext94; 1719 case 95: 1720 return vkdev_ext95; 1721 case 96: 1722 return vkdev_ext96; 1723 case 97: 1724 return vkdev_ext97; 1725 case 98: 1726 return vkdev_ext98; 1727 case 99: 1728 return vkdev_ext99; 1729 case 100: 1730 return vkdev_ext100; 1731 case 101: 1732 return vkdev_ext101; 1733 case 102: 1734 return vkdev_ext102; 1735 case 103: 1736 return vkdev_ext103; 1737 case 104: 1738 return vkdev_ext104; 1739 case 105: 1740 return vkdev_ext105; 1741 case 106: 1742 return vkdev_ext106; 1743 case 107: 1744 return vkdev_ext107; 1745 case 108: 1746 return vkdev_ext108; 1747 case 109: 1748 return vkdev_ext109; 1749 case 110: 1750 return vkdev_ext110; 1751 case 111: 1752 return vkdev_ext111; 1753 case 112: 1754 return vkdev_ext112; 1755 case 113: 1756 return vkdev_ext113; 1757 case 114: 1758 return vkdev_ext114; 1759 case 115: 1760 return vkdev_ext115; 1761 case 116: 1762 return vkdev_ext116; 1763 case 117: 1764 return vkdev_ext117; 1765 case 118: 1766 return vkdev_ext118; 1767 case 119: 1768 return vkdev_ext119; 1769 case 120: 1770 return vkdev_ext120; 1771 case 121: 1772 return vkdev_ext121; 1773 case 122: 1774 return vkdev_ext122; 1775 case 123: 1776 return vkdev_ext123; 1777 case 124: 1778 return vkdev_ext124; 1779 case 125: 1780 return vkdev_ext125; 1781 case 126: 1782 return vkdev_ext126; 1783 case 127: 1784 return vkdev_ext127; 1785 case 128: 1786 return vkdev_ext128; 1787 case 129: 1788 return vkdev_ext129; 1789 case 130: 1790 return vkdev_ext130; 1791 case 131: 1792 return vkdev_ext131; 1793 case 132: 1794 return vkdev_ext132; 1795 case 133: 1796 return vkdev_ext133; 1797 case 134: 1798 return vkdev_ext134; 1799 case 135: 1800 return vkdev_ext135; 1801 case 136: 1802 return vkdev_ext136; 1803 case 137: 1804 return vkdev_ext137; 1805 case 138: 1806 return vkdev_ext138; 1807 case 139: 1808 return vkdev_ext139; 1809 case 140: 1810 return vkdev_ext140; 1811 case 141: 1812 return vkdev_ext141; 1813 case 142: 1814 return vkdev_ext142; 1815 case 143: 1816 return vkdev_ext143; 1817 case 144: 1818 return vkdev_ext144; 1819 case 145: 1820 return vkdev_ext145; 1821 case 146: 1822 return vkdev_ext146; 1823 case 147: 1824 return vkdev_ext147; 1825 case 148: 1826 return vkdev_ext148; 1827 case 149: 1828 return vkdev_ext149; 1829 case 150: 1830 return vkdev_ext150; 1831 case 151: 1832 return vkdev_ext151; 1833 case 152: 1834 return vkdev_ext152; 1835 case 153: 1836 return vkdev_ext153; 1837 case 154: 1838 return vkdev_ext154; 1839 case 155: 1840 return vkdev_ext155; 1841 case 156: 1842 return vkdev_ext156; 1843 case 157: 1844 return vkdev_ext157; 1845 case 158: 1846 return vkdev_ext158; 1847 case 159: 1848 return vkdev_ext159; 1849 case 160: 1850 return vkdev_ext160; 1851 case 161: 1852 return vkdev_ext161; 1853 case 162: 1854 return vkdev_ext162; 1855 case 163: 1856 return vkdev_ext163; 1857 case 164: 1858 return vkdev_ext164; 1859 case 165: 1860 return vkdev_ext165; 1861 case 166: 1862 return vkdev_ext166; 1863 case 167: 1864 return vkdev_ext167; 1865 case 168: 1866 return vkdev_ext168; 1867 case 169: 1868 return vkdev_ext169; 1869 case 170: 1870 return vkdev_ext170; 1871 case 171: 1872 return vkdev_ext171; 1873 case 172: 1874 return vkdev_ext172; 1875 case 173: 1876 return vkdev_ext173; 1877 case 174: 1878 return vkdev_ext174; 1879 case 175: 1880 return vkdev_ext175; 1881 case 176: 1882 return vkdev_ext176; 1883 case 177: 1884 return vkdev_ext177; 1885 case 178: 1886 return vkdev_ext178; 1887 case 179: 1888 return vkdev_ext179; 1889 case 180: 1890 return vkdev_ext180; 1891 case 181: 1892 return vkdev_ext181; 1893 case 182: 1894 return vkdev_ext182; 1895 case 183: 1896 return vkdev_ext183; 1897 case 184: 1898 return vkdev_ext184; 1899 case 185: 1900 return vkdev_ext185; 1901 case 186: 1902 return vkdev_ext186; 1903 case 187: 1904 return vkdev_ext187; 1905 case 188: 1906 return vkdev_ext188; 1907 case 189: 1908 return vkdev_ext189; 1909 case 190: 1910 return vkdev_ext190; 1911 case 191: 1912 return vkdev_ext191; 1913 case 192: 1914 return vkdev_ext192; 1915 case 193: 1916 return vkdev_ext193; 1917 case 194: 1918 return vkdev_ext194; 1919 case 195: 1920 return vkdev_ext195; 1921 case 196: 1922 return vkdev_ext196; 1923 case 197: 1924 return vkdev_ext197; 1925 case 198: 1926 return vkdev_ext198; 1927 case 199: 1928 return vkdev_ext199; 1929 case 200: 1930 return vkdev_ext200; 1931 case 201: 1932 return vkdev_ext201; 1933 case 202: 1934 return vkdev_ext202; 1935 case 203: 1936 return vkdev_ext203; 1937 case 204: 1938 return vkdev_ext204; 1939 case 205: 1940 return vkdev_ext205; 1941 case 206: 1942 return vkdev_ext206; 1943 case 207: 1944 return vkdev_ext207; 1945 case 208: 1946 return vkdev_ext208; 1947 case 209: 1948 return vkdev_ext209; 1949 case 210: 1950 return vkdev_ext210; 1951 case 211: 1952 return vkdev_ext211; 1953 case 212: 1954 return vkdev_ext212; 1955 case 213: 1956 return vkdev_ext213; 1957 case 214: 1958 return vkdev_ext214; 1959 case 215: 1960 return vkdev_ext215; 1961 case 216: 1962 return vkdev_ext216; 1963 case 217: 1964 return vkdev_ext217; 1965 case 218: 1966 return vkdev_ext218; 1967 case 219: 1968 return vkdev_ext219; 1969 case 220: 1970 return vkdev_ext220; 1971 case 221: 1972 return vkdev_ext221; 1973 case 222: 1974 return vkdev_ext222; 1975 case 223: 1976 return vkdev_ext223; 1977 case 224: 1978 return vkdev_ext224; 1979 case 225: 1980 return vkdev_ext225; 1981 case 226: 1982 return vkdev_ext226; 1983 case 227: 1984 return vkdev_ext227; 1985 case 228: 1986 return vkdev_ext228; 1987 case 229: 1988 return vkdev_ext229; 1989 case 230: 1990 return vkdev_ext230; 1991 case 231: 1992 return vkdev_ext231; 1993 case 232: 1994 return vkdev_ext232; 1995 case 233: 1996 return vkdev_ext233; 1997 case 234: 1998 return vkdev_ext234; 1999 case 235: 2000 return vkdev_ext235; 2001 case 236: 2002 return vkdev_ext236; 2003 case 237: 2004 return vkdev_ext237; 2005 case 238: 2006 return vkdev_ext238; 2007 case 239: 2008 return vkdev_ext239; 2009 case 240: 2010 return vkdev_ext240; 2011 case 241: 2012 return vkdev_ext241; 2013 case 242: 2014 return vkdev_ext242; 2015 case 243: 2016 return vkdev_ext243; 2017 case 244: 2018 return vkdev_ext244; 2019 case 245: 2020 return vkdev_ext245; 2021 case 246: 2022 return vkdev_ext246; 2023 case 247: 2024 return vkdev_ext247; 2025 case 248: 2026 return vkdev_ext248; 2027 case 249: 2028 return vkdev_ext249; 2029 } 2030 return NULL; 2031 } 2032
