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@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
27VKAPI_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
33VKAPI_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
39VKAPI_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
45VKAPI_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
51VKAPI_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
57VKAPI_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
63VKAPI_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
69VKAPI_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
75VKAPI_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
81VKAPI_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
87VKAPI_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
93VKAPI_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
99VKAPI_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
105VKAPI_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
111VKAPI_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
117VKAPI_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
123VKAPI_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
129VKAPI_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
135VKAPI_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
141VKAPI_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
147VKAPI_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
153VKAPI_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
159VKAPI_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
165VKAPI_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
171VKAPI_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
177VKAPI_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
183VKAPI_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
189VKAPI_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
195VKAPI_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
201VKAPI_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
207VKAPI_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
213VKAPI_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
219VKAPI_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
225VKAPI_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
231VKAPI_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
237VKAPI_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
243VKAPI_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
249VKAPI_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
255VKAPI_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
261VKAPI_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
267VKAPI_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
273VKAPI_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
279VKAPI_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
285VKAPI_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
291VKAPI_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
297VKAPI_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
303VKAPI_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
309VKAPI_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
315VKAPI_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
321VKAPI_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
327VKAPI_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
333VKAPI_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
339VKAPI_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
345VKAPI_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
351VKAPI_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
357VKAPI_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
363VKAPI_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
369VKAPI_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
375VKAPI_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
381VKAPI_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
387VKAPI_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
393VKAPI_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
399VKAPI_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
405VKAPI_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
411VKAPI_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
417VKAPI_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
423VKAPI_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
429VKAPI_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
435VKAPI_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
441VKAPI_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
447VKAPI_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
453VKAPI_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
459VKAPI_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
465VKAPI_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
471VKAPI_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
477VKAPI_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
483VKAPI_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
489VKAPI_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
495VKAPI_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
501VKAPI_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
507VKAPI_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
513VKAPI_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
519VKAPI_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
525VKAPI_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
531VKAPI_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
537VKAPI_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
543VKAPI_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
549VKAPI_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
555VKAPI_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
561VKAPI_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
567VKAPI_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
573VKAPI_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
579VKAPI_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
585VKAPI_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
591VKAPI_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
597VKAPI_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
603VKAPI_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
609VKAPI_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
615VKAPI_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
621VKAPI_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
627VKAPI_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
633VKAPI_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
639VKAPI_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
645VKAPI_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
651VKAPI_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
657VKAPI_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
663VKAPI_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
669VKAPI_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
675VKAPI_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
681VKAPI_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
687VKAPI_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
693VKAPI_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
699VKAPI_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
705VKAPI_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
711VKAPI_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
717VKAPI_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
723VKAPI_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
729VKAPI_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
735VKAPI_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
741VKAPI_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
747VKAPI_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
753VKAPI_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
759VKAPI_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
765VKAPI_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
771VKAPI_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
777VKAPI_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
783VKAPI_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
789VKAPI_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
795VKAPI_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
801VKAPI_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
807VKAPI_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
813VKAPI_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
819VKAPI_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
825VKAPI_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
831VKAPI_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
837VKAPI_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
843VKAPI_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
849VKAPI_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
855VKAPI_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
861VKAPI_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
867VKAPI_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
873VKAPI_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
879VKAPI_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
885VKAPI_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
891VKAPI_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
897VKAPI_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
903VKAPI_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
909VKAPI_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
915VKAPI_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
921VKAPI_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
927VKAPI_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
933VKAPI_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
939VKAPI_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
945VKAPI_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
951VKAPI_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
957VKAPI_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
963VKAPI_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
969VKAPI_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
975VKAPI_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
981VKAPI_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
987VKAPI_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
993VKAPI_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
999VKAPI_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
1005VKAPI_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
1011VKAPI_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
1017VKAPI_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
1023VKAPI_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
1029VKAPI_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
1035VKAPI_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
1041VKAPI_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
1047VKAPI_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
1053VKAPI_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
1059VKAPI_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
1065VKAPI_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
1071VKAPI_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
1077VKAPI_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
1083VKAPI_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
1089VKAPI_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
1095VKAPI_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
1101VKAPI_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
1107VKAPI_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
1113VKAPI_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
1119VKAPI_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
1125VKAPI_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
1131VKAPI_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
1137VKAPI_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
1143VKAPI_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
1149VKAPI_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
1155VKAPI_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
1161VKAPI_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
1167VKAPI_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
1173VKAPI_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
1179VKAPI_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
1185VKAPI_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
1191VKAPI_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
1197VKAPI_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
1203VKAPI_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
1209VKAPI_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
1215VKAPI_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
1221VKAPI_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
1227VKAPI_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
1233VKAPI_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
1239VKAPI_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
1245VKAPI_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
1251VKAPI_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
1257VKAPI_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
1263VKAPI_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
1269VKAPI_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
1275VKAPI_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
1281VKAPI_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
1287VKAPI_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
1293VKAPI_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
1299VKAPI_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
1305VKAPI_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
1311VKAPI_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
1317VKAPI_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
1323VKAPI_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
1329VKAPI_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
1335VKAPI_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
1341VKAPI_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
1347VKAPI_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
1353VKAPI_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
1359VKAPI_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
1365VKAPI_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
1371VKAPI_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
1377VKAPI_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
1383VKAPI_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
1389VKAPI_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
1395VKAPI_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
1401VKAPI_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
1407VKAPI_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
1413VKAPI_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
1419VKAPI_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
1425VKAPI_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
1431VKAPI_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
1437VKAPI_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
1443VKAPI_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
1449VKAPI_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
1455VKAPI_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
1461VKAPI_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
1467VKAPI_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
1473VKAPI_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
1479VKAPI_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
1485VKAPI_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
1491VKAPI_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
1497VKAPI_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
1503VKAPI_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
1509VKAPI_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
1515VKAPI_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
1521VKAPI_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
1527void *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