vulkan-rust-sys 0.10.0

Raw Vulkan FFI types generated from vk.xml
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
// Auto-generated by the generator crate. Do not edit.
use core::mem::{offset_of, size_of, align_of};
use vulkan_rust_sys::*;

fn main() {
    println!("BaseOutStructure {} {} {} {}", size_of::<BaseOutStructure>(), align_of::<BaseOutStructure>(), offset_of!(BaseOutStructure, s_type), offset_of!(BaseOutStructure, p_next));
    println!("BaseInStructure {} {} {} {}", size_of::<BaseInStructure>(), align_of::<BaseInStructure>(), offset_of!(BaseInStructure, s_type), offset_of!(BaseInStructure, p_next));
    println!("Offset2D {} {} {} {}", size_of::<Offset2D>(), align_of::<Offset2D>(), offset_of!(Offset2D, x), offset_of!(Offset2D, y));
    println!("Offset3D {} {} {} {} {}", size_of::<Offset3D>(), align_of::<Offset3D>(), offset_of!(Offset3D, x), offset_of!(Offset3D, y), offset_of!(Offset3D, z));
    println!("Extent2D {} {} {} {}", size_of::<Extent2D>(), align_of::<Extent2D>(), offset_of!(Extent2D, width), offset_of!(Extent2D, height));
    println!("Extent3D {} {} {} {} {}", size_of::<Extent3D>(), align_of::<Extent3D>(), offset_of!(Extent3D, width), offset_of!(Extent3D, height), offset_of!(Extent3D, depth));
    println!("Viewport {} {} {} {} {} {} {} {}", size_of::<Viewport>(), align_of::<Viewport>(), offset_of!(Viewport, x), offset_of!(Viewport, y), offset_of!(Viewport, width), offset_of!(Viewport, height), offset_of!(Viewport, min_depth), offset_of!(Viewport, max_depth));
    println!("Rect2D {} {} {} {}", size_of::<Rect2D>(), align_of::<Rect2D>(), offset_of!(Rect2D, offset), offset_of!(Rect2D, extent));
    println!("ClearRect {} {} {} {} {}", size_of::<ClearRect>(), align_of::<ClearRect>(), offset_of!(ClearRect, rect), offset_of!(ClearRect, base_array_layer), offset_of!(ClearRect, layer_count));
    println!("ComponentMapping {} {} {} {} {} {}", size_of::<ComponentMapping>(), align_of::<ComponentMapping>(), offset_of!(ComponentMapping, r), offset_of!(ComponentMapping, g), offset_of!(ComponentMapping, b), offset_of!(ComponentMapping, a));
    println!("PhysicalDeviceProperties {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceProperties>(), align_of::<PhysicalDeviceProperties>(), offset_of!(PhysicalDeviceProperties, api_version), offset_of!(PhysicalDeviceProperties, driver_version), offset_of!(PhysicalDeviceProperties, vendor_id), offset_of!(PhysicalDeviceProperties, device_id), offset_of!(PhysicalDeviceProperties, device_type), offset_of!(PhysicalDeviceProperties, device_name), offset_of!(PhysicalDeviceProperties, pipeline_cache_uuid), offset_of!(PhysicalDeviceProperties, limits), offset_of!(PhysicalDeviceProperties, sparse_properties));
    println!("ExtensionProperties {} {} {} {}", size_of::<ExtensionProperties>(), align_of::<ExtensionProperties>(), offset_of!(ExtensionProperties, extension_name), offset_of!(ExtensionProperties, spec_version));
    println!("LayerProperties {} {} {} {} {} {}", size_of::<LayerProperties>(), align_of::<LayerProperties>(), offset_of!(LayerProperties, layer_name), offset_of!(LayerProperties, spec_version), offset_of!(LayerProperties, implementation_version), offset_of!(LayerProperties, description));
    println!("ApplicationInfo {} {} {} {} {} {} {} {} {}", size_of::<ApplicationInfo>(), align_of::<ApplicationInfo>(), offset_of!(ApplicationInfo, s_type), offset_of!(ApplicationInfo, p_next), offset_of!(ApplicationInfo, p_application_name), offset_of!(ApplicationInfo, application_version), offset_of!(ApplicationInfo, p_engine_name), offset_of!(ApplicationInfo, engine_version), offset_of!(ApplicationInfo, api_version));
    println!("AllocationCallbacks {} {} {} {} {} {} {} {}", size_of::<AllocationCallbacks>(), align_of::<AllocationCallbacks>(), offset_of!(AllocationCallbacks, p_user_data), offset_of!(AllocationCallbacks, pfn_allocation), offset_of!(AllocationCallbacks, pfn_reallocation), offset_of!(AllocationCallbacks, pfn_free), offset_of!(AllocationCallbacks, pfn_internal_allocation), offset_of!(AllocationCallbacks, pfn_internal_free));
    println!("DeviceQueueCreateInfo {} {} {} {} {} {} {} {}", size_of::<DeviceQueueCreateInfo>(), align_of::<DeviceQueueCreateInfo>(), offset_of!(DeviceQueueCreateInfo, s_type), offset_of!(DeviceQueueCreateInfo, p_next), offset_of!(DeviceQueueCreateInfo, flags), offset_of!(DeviceQueueCreateInfo, queue_family_index), offset_of!(DeviceQueueCreateInfo, queue_count), offset_of!(DeviceQueueCreateInfo, p_queue_priorities));
    println!("DeviceCreateInfo {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DeviceCreateInfo>(), align_of::<DeviceCreateInfo>(), offset_of!(DeviceCreateInfo, s_type), offset_of!(DeviceCreateInfo, p_next), offset_of!(DeviceCreateInfo, flags), offset_of!(DeviceCreateInfo, queue_create_info_count), offset_of!(DeviceCreateInfo, p_queue_create_infos), offset_of!(DeviceCreateInfo, enabled_layer_count), offset_of!(DeviceCreateInfo, pp_enabled_layer_names), offset_of!(DeviceCreateInfo, enabled_extension_count), offset_of!(DeviceCreateInfo, pp_enabled_extension_names), offset_of!(DeviceCreateInfo, p_enabled_features));
    println!("InstanceCreateInfo {} {} {} {} {} {} {} {} {} {}", size_of::<InstanceCreateInfo>(), align_of::<InstanceCreateInfo>(), offset_of!(InstanceCreateInfo, s_type), offset_of!(InstanceCreateInfo, p_next), offset_of!(InstanceCreateInfo, flags), offset_of!(InstanceCreateInfo, p_application_info), offset_of!(InstanceCreateInfo, enabled_layer_count), offset_of!(InstanceCreateInfo, pp_enabled_layer_names), offset_of!(InstanceCreateInfo, enabled_extension_count), offset_of!(InstanceCreateInfo, pp_enabled_extension_names));
    println!("QueueFamilyProperties {} {} {} {} {} {}", size_of::<QueueFamilyProperties>(), align_of::<QueueFamilyProperties>(), offset_of!(QueueFamilyProperties, queue_flags), offset_of!(QueueFamilyProperties, queue_count), offset_of!(QueueFamilyProperties, timestamp_valid_bits), offset_of!(QueueFamilyProperties, min_image_transfer_granularity));
    println!("PhysicalDeviceMemoryProperties {} {} {} {} {} {}", size_of::<PhysicalDeviceMemoryProperties>(), align_of::<PhysicalDeviceMemoryProperties>(), offset_of!(PhysicalDeviceMemoryProperties, memory_type_count), offset_of!(PhysicalDeviceMemoryProperties, memory_types), offset_of!(PhysicalDeviceMemoryProperties, memory_heap_count), offset_of!(PhysicalDeviceMemoryProperties, memory_heaps));
    println!("MemoryAllocateInfo {} {} {} {} {} {}", size_of::<MemoryAllocateInfo>(), align_of::<MemoryAllocateInfo>(), offset_of!(MemoryAllocateInfo, s_type), offset_of!(MemoryAllocateInfo, p_next), offset_of!(MemoryAllocateInfo, allocation_size), offset_of!(MemoryAllocateInfo, memory_type_index));
    println!("MemoryRequirements {} {} {} {} {}", size_of::<MemoryRequirements>(), align_of::<MemoryRequirements>(), offset_of!(MemoryRequirements, size), offset_of!(MemoryRequirements, alignment), offset_of!(MemoryRequirements, memory_type_bits));
    println!("SparseImageFormatProperties {} {} {} {} {}", size_of::<SparseImageFormatProperties>(), align_of::<SparseImageFormatProperties>(), offset_of!(SparseImageFormatProperties, aspect_mask), offset_of!(SparseImageFormatProperties, image_granularity), offset_of!(SparseImageFormatProperties, flags));
    println!("SparseImageMemoryRequirements {} {} {} {} {} {} {}", size_of::<SparseImageMemoryRequirements>(), align_of::<SparseImageMemoryRequirements>(), offset_of!(SparseImageMemoryRequirements, format_properties), offset_of!(SparseImageMemoryRequirements, image_mip_tail_first_lod), offset_of!(SparseImageMemoryRequirements, image_mip_tail_size), offset_of!(SparseImageMemoryRequirements, image_mip_tail_offset), offset_of!(SparseImageMemoryRequirements, image_mip_tail_stride));
    println!("MemoryType {} {} {} {}", size_of::<MemoryType>(), align_of::<MemoryType>(), offset_of!(MemoryType, property_flags), offset_of!(MemoryType, heap_index));
    println!("MemoryHeap {} {} {} {}", size_of::<MemoryHeap>(), align_of::<MemoryHeap>(), offset_of!(MemoryHeap, size), offset_of!(MemoryHeap, flags));
    println!("MappedMemoryRange {} {} {} {} {} {} {}", size_of::<MappedMemoryRange>(), align_of::<MappedMemoryRange>(), offset_of!(MappedMemoryRange, s_type), offset_of!(MappedMemoryRange, p_next), offset_of!(MappedMemoryRange, memory), offset_of!(MappedMemoryRange, offset), offset_of!(MappedMemoryRange, size));
    println!("FormatProperties {} {} {} {} {}", size_of::<FormatProperties>(), align_of::<FormatProperties>(), offset_of!(FormatProperties, linear_tiling_features), offset_of!(FormatProperties, optimal_tiling_features), offset_of!(FormatProperties, buffer_features));
    println!("ImageFormatProperties {} {} {} {} {} {} {}", size_of::<ImageFormatProperties>(), align_of::<ImageFormatProperties>(), offset_of!(ImageFormatProperties, max_extent), offset_of!(ImageFormatProperties, max_mip_levels), offset_of!(ImageFormatProperties, max_array_layers), offset_of!(ImageFormatProperties, sample_counts), offset_of!(ImageFormatProperties, max_resource_size));
    println!("DescriptorBufferInfo {} {} {} {} {}", size_of::<DescriptorBufferInfo>(), align_of::<DescriptorBufferInfo>(), offset_of!(DescriptorBufferInfo, buffer), offset_of!(DescriptorBufferInfo, offset), offset_of!(DescriptorBufferInfo, range));
    println!("DescriptorImageInfo {} {} {} {} {}", size_of::<DescriptorImageInfo>(), align_of::<DescriptorImageInfo>(), offset_of!(DescriptorImageInfo, sampler), offset_of!(DescriptorImageInfo, image_view), offset_of!(DescriptorImageInfo, image_layout));
    println!("WriteDescriptorSet {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<WriteDescriptorSet>(), align_of::<WriteDescriptorSet>(), offset_of!(WriteDescriptorSet, s_type), offset_of!(WriteDescriptorSet, p_next), offset_of!(WriteDescriptorSet, dst_set), offset_of!(WriteDescriptorSet, dst_binding), offset_of!(WriteDescriptorSet, dst_array_element), offset_of!(WriteDescriptorSet, descriptor_count), offset_of!(WriteDescriptorSet, descriptor_type), offset_of!(WriteDescriptorSet, p_image_info), offset_of!(WriteDescriptorSet, p_buffer_info), offset_of!(WriteDescriptorSet, p_texel_buffer_view));
    println!("CopyDescriptorSet {} {} {} {} {} {} {} {} {} {} {}", size_of::<CopyDescriptorSet>(), align_of::<CopyDescriptorSet>(), offset_of!(CopyDescriptorSet, s_type), offset_of!(CopyDescriptorSet, p_next), offset_of!(CopyDescriptorSet, src_set), offset_of!(CopyDescriptorSet, src_binding), offset_of!(CopyDescriptorSet, src_array_element), offset_of!(CopyDescriptorSet, dst_set), offset_of!(CopyDescriptorSet, dst_binding), offset_of!(CopyDescriptorSet, dst_array_element), offset_of!(CopyDescriptorSet, descriptor_count));
    println!("BufferUsageFlags2CreateInfo {} {} {} {} {}", size_of::<BufferUsageFlags2CreateInfo>(), align_of::<BufferUsageFlags2CreateInfo>(), offset_of!(BufferUsageFlags2CreateInfo, s_type), offset_of!(BufferUsageFlags2CreateInfo, p_next), offset_of!(BufferUsageFlags2CreateInfo, usage));
    println!("BufferCreateInfo {} {} {} {} {} {} {} {} {} {}", size_of::<BufferCreateInfo>(), align_of::<BufferCreateInfo>(), offset_of!(BufferCreateInfo, s_type), offset_of!(BufferCreateInfo, p_next), offset_of!(BufferCreateInfo, flags), offset_of!(BufferCreateInfo, size), offset_of!(BufferCreateInfo, usage), offset_of!(BufferCreateInfo, sharing_mode), offset_of!(BufferCreateInfo, queue_family_index_count), offset_of!(BufferCreateInfo, p_queue_family_indices));
    println!("BufferViewCreateInfo {} {} {} {} {} {} {} {} {}", size_of::<BufferViewCreateInfo>(), align_of::<BufferViewCreateInfo>(), offset_of!(BufferViewCreateInfo, s_type), offset_of!(BufferViewCreateInfo, p_next), offset_of!(BufferViewCreateInfo, flags), offset_of!(BufferViewCreateInfo, buffer), offset_of!(BufferViewCreateInfo, format), offset_of!(BufferViewCreateInfo, offset), offset_of!(BufferViewCreateInfo, range));
    println!("ImageSubresource {} {} {} {} {}", size_of::<ImageSubresource>(), align_of::<ImageSubresource>(), offset_of!(ImageSubresource, aspect_mask), offset_of!(ImageSubresource, mip_level), offset_of!(ImageSubresource, array_layer));
    println!("ImageSubresourceLayers {} {} {} {} {} {}", size_of::<ImageSubresourceLayers>(), align_of::<ImageSubresourceLayers>(), offset_of!(ImageSubresourceLayers, aspect_mask), offset_of!(ImageSubresourceLayers, mip_level), offset_of!(ImageSubresourceLayers, base_array_layer), offset_of!(ImageSubresourceLayers, layer_count));
    println!("ImageSubresourceRange {} {} {} {} {} {} {}", size_of::<ImageSubresourceRange>(), align_of::<ImageSubresourceRange>(), offset_of!(ImageSubresourceRange, aspect_mask), offset_of!(ImageSubresourceRange, base_mip_level), offset_of!(ImageSubresourceRange, level_count), offset_of!(ImageSubresourceRange, base_array_layer), offset_of!(ImageSubresourceRange, layer_count));
    println!("MemoryBarrier {} {} {} {} {} {}", size_of::<MemoryBarrier>(), align_of::<MemoryBarrier>(), offset_of!(MemoryBarrier, s_type), offset_of!(MemoryBarrier, p_next), offset_of!(MemoryBarrier, src_access_mask), offset_of!(MemoryBarrier, dst_access_mask));
    println!("BufferMemoryBarrier {} {} {} {} {} {} {} {} {} {} {}", size_of::<BufferMemoryBarrier>(), align_of::<BufferMemoryBarrier>(), offset_of!(BufferMemoryBarrier, s_type), offset_of!(BufferMemoryBarrier, p_next), offset_of!(BufferMemoryBarrier, src_access_mask), offset_of!(BufferMemoryBarrier, dst_access_mask), offset_of!(BufferMemoryBarrier, src_queue_family_index), offset_of!(BufferMemoryBarrier, dst_queue_family_index), offset_of!(BufferMemoryBarrier, buffer), offset_of!(BufferMemoryBarrier, offset), offset_of!(BufferMemoryBarrier, size));
    println!("ImageMemoryBarrier {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ImageMemoryBarrier>(), align_of::<ImageMemoryBarrier>(), offset_of!(ImageMemoryBarrier, s_type), offset_of!(ImageMemoryBarrier, p_next), offset_of!(ImageMemoryBarrier, src_access_mask), offset_of!(ImageMemoryBarrier, dst_access_mask), offset_of!(ImageMemoryBarrier, old_layout), offset_of!(ImageMemoryBarrier, new_layout), offset_of!(ImageMemoryBarrier, src_queue_family_index), offset_of!(ImageMemoryBarrier, dst_queue_family_index), offset_of!(ImageMemoryBarrier, image), offset_of!(ImageMemoryBarrier, subresource_range));
    println!("ImageCreateInfo {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ImageCreateInfo>(), align_of::<ImageCreateInfo>(), offset_of!(ImageCreateInfo, s_type), offset_of!(ImageCreateInfo, p_next), offset_of!(ImageCreateInfo, flags), offset_of!(ImageCreateInfo, image_type), offset_of!(ImageCreateInfo, format), offset_of!(ImageCreateInfo, extent), offset_of!(ImageCreateInfo, mip_levels), offset_of!(ImageCreateInfo, array_layers), offset_of!(ImageCreateInfo, samples), offset_of!(ImageCreateInfo, tiling), offset_of!(ImageCreateInfo, usage), offset_of!(ImageCreateInfo, sharing_mode), offset_of!(ImageCreateInfo, queue_family_index_count), offset_of!(ImageCreateInfo, p_queue_family_indices), offset_of!(ImageCreateInfo, initial_layout));
    println!("SubresourceLayout {} {} {} {} {} {} {}", size_of::<SubresourceLayout>(), align_of::<SubresourceLayout>(), offset_of!(SubresourceLayout, offset), offset_of!(SubresourceLayout, size), offset_of!(SubresourceLayout, row_pitch), offset_of!(SubresourceLayout, array_pitch), offset_of!(SubresourceLayout, depth_pitch));
    println!("ImageViewCreateInfo {} {} {} {} {} {} {} {} {} {}", size_of::<ImageViewCreateInfo>(), align_of::<ImageViewCreateInfo>(), offset_of!(ImageViewCreateInfo, s_type), offset_of!(ImageViewCreateInfo, p_next), offset_of!(ImageViewCreateInfo, flags), offset_of!(ImageViewCreateInfo, image), offset_of!(ImageViewCreateInfo, view_type), offset_of!(ImageViewCreateInfo, format), offset_of!(ImageViewCreateInfo, components), offset_of!(ImageViewCreateInfo, subresource_range));
    println!("BufferCopy {} {} {} {} {}", size_of::<BufferCopy>(), align_of::<BufferCopy>(), offset_of!(BufferCopy, src_offset), offset_of!(BufferCopy, dst_offset), offset_of!(BufferCopy, size));
    println!("SparseMemoryBind {} {} {} {} {} {} {}", size_of::<SparseMemoryBind>(), align_of::<SparseMemoryBind>(), offset_of!(SparseMemoryBind, resource_offset), offset_of!(SparseMemoryBind, size), offset_of!(SparseMemoryBind, memory), offset_of!(SparseMemoryBind, memory_offset), offset_of!(SparseMemoryBind, flags));
    println!("SparseImageMemoryBind {} {} {} {} {} {} {} {}", size_of::<SparseImageMemoryBind>(), align_of::<SparseImageMemoryBind>(), offset_of!(SparseImageMemoryBind, subresource), offset_of!(SparseImageMemoryBind, offset), offset_of!(SparseImageMemoryBind, extent), offset_of!(SparseImageMemoryBind, memory), offset_of!(SparseImageMemoryBind, memory_offset), offset_of!(SparseImageMemoryBind, flags));
    println!("SparseBufferMemoryBindInfo {} {} {} {} {}", size_of::<SparseBufferMemoryBindInfo>(), align_of::<SparseBufferMemoryBindInfo>(), offset_of!(SparseBufferMemoryBindInfo, buffer), offset_of!(SparseBufferMemoryBindInfo, bind_count), offset_of!(SparseBufferMemoryBindInfo, p_binds));
    println!("SparseImageOpaqueMemoryBindInfo {} {} {} {} {}", size_of::<SparseImageOpaqueMemoryBindInfo>(), align_of::<SparseImageOpaqueMemoryBindInfo>(), offset_of!(SparseImageOpaqueMemoryBindInfo, image), offset_of!(SparseImageOpaqueMemoryBindInfo, bind_count), offset_of!(SparseImageOpaqueMemoryBindInfo, p_binds));
    println!("SparseImageMemoryBindInfo {} {} {} {} {}", size_of::<SparseImageMemoryBindInfo>(), align_of::<SparseImageMemoryBindInfo>(), offset_of!(SparseImageMemoryBindInfo, image), offset_of!(SparseImageMemoryBindInfo, bind_count), offset_of!(SparseImageMemoryBindInfo, p_binds));
    println!("BindSparseInfo {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<BindSparseInfo>(), align_of::<BindSparseInfo>(), offset_of!(BindSparseInfo, s_type), offset_of!(BindSparseInfo, p_next), offset_of!(BindSparseInfo, wait_semaphore_count), offset_of!(BindSparseInfo, p_wait_semaphores), offset_of!(BindSparseInfo, buffer_bind_count), offset_of!(BindSparseInfo, p_buffer_binds), offset_of!(BindSparseInfo, image_opaque_bind_count), offset_of!(BindSparseInfo, p_image_opaque_binds), offset_of!(BindSparseInfo, image_bind_count), offset_of!(BindSparseInfo, p_image_binds), offset_of!(BindSparseInfo, signal_semaphore_count), offset_of!(BindSparseInfo, p_signal_semaphores));
    println!("ImageCopy {} {} {} {} {} {} {}", size_of::<ImageCopy>(), align_of::<ImageCopy>(), offset_of!(ImageCopy, src_subresource), offset_of!(ImageCopy, src_offset), offset_of!(ImageCopy, dst_subresource), offset_of!(ImageCopy, dst_offset), offset_of!(ImageCopy, extent));
    println!("ImageBlit {} {} {} {} {} {}", size_of::<ImageBlit>(), align_of::<ImageBlit>(), offset_of!(ImageBlit, src_subresource), offset_of!(ImageBlit, src_offsets), offset_of!(ImageBlit, dst_subresource), offset_of!(ImageBlit, dst_offsets));
    println!("BufferImageCopy {} {} {} {} {} {} {} {}", size_of::<BufferImageCopy>(), align_of::<BufferImageCopy>(), offset_of!(BufferImageCopy, buffer_offset), offset_of!(BufferImageCopy, buffer_row_length), offset_of!(BufferImageCopy, buffer_image_height), offset_of!(BufferImageCopy, image_subresource), offset_of!(BufferImageCopy, image_offset), offset_of!(BufferImageCopy, image_extent));
    println!("StridedDeviceAddressRangeKHR {} {} {} {} {}", size_of::<StridedDeviceAddressRangeKHR>(), align_of::<StridedDeviceAddressRangeKHR>(), offset_of!(StridedDeviceAddressRangeKHR, address), offset_of!(StridedDeviceAddressRangeKHR, size), offset_of!(StridedDeviceAddressRangeKHR, stride));
    println!("CopyMemoryIndirectCommandKHR {} {} {} {} {}", size_of::<CopyMemoryIndirectCommandKHR>(), align_of::<CopyMemoryIndirectCommandKHR>(), offset_of!(CopyMemoryIndirectCommandKHR, src_address), offset_of!(CopyMemoryIndirectCommandKHR, dst_address), offset_of!(CopyMemoryIndirectCommandKHR, size));
    println!("CopyMemoryIndirectInfoKHR {} {} {} {} {} {} {} {}", size_of::<CopyMemoryIndirectInfoKHR>(), align_of::<CopyMemoryIndirectInfoKHR>(), offset_of!(CopyMemoryIndirectInfoKHR, s_type), offset_of!(CopyMemoryIndirectInfoKHR, p_next), offset_of!(CopyMemoryIndirectInfoKHR, src_copy_flags), offset_of!(CopyMemoryIndirectInfoKHR, dst_copy_flags), offset_of!(CopyMemoryIndirectInfoKHR, copy_count), offset_of!(CopyMemoryIndirectInfoKHR, copy_address_range));
    println!("CopyMemoryToImageIndirectCommandKHR {} {} {} {} {} {} {} {}", size_of::<CopyMemoryToImageIndirectCommandKHR>(), align_of::<CopyMemoryToImageIndirectCommandKHR>(), offset_of!(CopyMemoryToImageIndirectCommandKHR, src_address), offset_of!(CopyMemoryToImageIndirectCommandKHR, buffer_row_length), offset_of!(CopyMemoryToImageIndirectCommandKHR, buffer_image_height), offset_of!(CopyMemoryToImageIndirectCommandKHR, image_subresource), offset_of!(CopyMemoryToImageIndirectCommandKHR, image_offset), offset_of!(CopyMemoryToImageIndirectCommandKHR, image_extent));
    println!("CopyMemoryToImageIndirectInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<CopyMemoryToImageIndirectInfoKHR>(), align_of::<CopyMemoryToImageIndirectInfoKHR>(), offset_of!(CopyMemoryToImageIndirectInfoKHR, s_type), offset_of!(CopyMemoryToImageIndirectInfoKHR, p_next), offset_of!(CopyMemoryToImageIndirectInfoKHR, src_copy_flags), offset_of!(CopyMemoryToImageIndirectInfoKHR, copy_count), offset_of!(CopyMemoryToImageIndirectInfoKHR, copy_address_range), offset_of!(CopyMemoryToImageIndirectInfoKHR, dst_image), offset_of!(CopyMemoryToImageIndirectInfoKHR, dst_image_layout), offset_of!(CopyMemoryToImageIndirectInfoKHR, p_image_subresources));
    println!("ImageResolve {} {} {} {} {} {} {}", size_of::<ImageResolve>(), align_of::<ImageResolve>(), offset_of!(ImageResolve, src_subresource), offset_of!(ImageResolve, src_offset), offset_of!(ImageResolve, dst_subresource), offset_of!(ImageResolve, dst_offset), offset_of!(ImageResolve, extent));
    println!("ShaderModuleCreateInfo {} {} {} {} {} {} {}", size_of::<ShaderModuleCreateInfo>(), align_of::<ShaderModuleCreateInfo>(), offset_of!(ShaderModuleCreateInfo, s_type), offset_of!(ShaderModuleCreateInfo, p_next), offset_of!(ShaderModuleCreateInfo, flags), offset_of!(ShaderModuleCreateInfo, code_size), offset_of!(ShaderModuleCreateInfo, p_code));
    println!("DescriptorSetLayoutBinding {} {} {} {} {} {} {}", size_of::<DescriptorSetLayoutBinding>(), align_of::<DescriptorSetLayoutBinding>(), offset_of!(DescriptorSetLayoutBinding, binding), offset_of!(DescriptorSetLayoutBinding, descriptor_type), offset_of!(DescriptorSetLayoutBinding, descriptor_count), offset_of!(DescriptorSetLayoutBinding, stage_flags), offset_of!(DescriptorSetLayoutBinding, p_immutable_samplers));
    println!("DescriptorSetLayoutCreateInfo {} {} {} {} {} {} {}", size_of::<DescriptorSetLayoutCreateInfo>(), align_of::<DescriptorSetLayoutCreateInfo>(), offset_of!(DescriptorSetLayoutCreateInfo, s_type), offset_of!(DescriptorSetLayoutCreateInfo, p_next), offset_of!(DescriptorSetLayoutCreateInfo, flags), offset_of!(DescriptorSetLayoutCreateInfo, binding_count), offset_of!(DescriptorSetLayoutCreateInfo, p_bindings));
    println!("DescriptorPoolSize {} {} {}", size_of::<DescriptorPoolSize>(), align_of::<DescriptorPoolSize>(), offset_of!(DescriptorPoolSize, descriptor_count));
    println!("DescriptorPoolCreateInfo {} {} {} {} {} {} {} {}", size_of::<DescriptorPoolCreateInfo>(), align_of::<DescriptorPoolCreateInfo>(), offset_of!(DescriptorPoolCreateInfo, s_type), offset_of!(DescriptorPoolCreateInfo, p_next), offset_of!(DescriptorPoolCreateInfo, flags), offset_of!(DescriptorPoolCreateInfo, max_sets), offset_of!(DescriptorPoolCreateInfo, pool_size_count), offset_of!(DescriptorPoolCreateInfo, p_pool_sizes));
    println!("DescriptorSetAllocateInfo {} {} {} {} {} {} {}", size_of::<DescriptorSetAllocateInfo>(), align_of::<DescriptorSetAllocateInfo>(), offset_of!(DescriptorSetAllocateInfo, s_type), offset_of!(DescriptorSetAllocateInfo, p_next), offset_of!(DescriptorSetAllocateInfo, descriptor_pool), offset_of!(DescriptorSetAllocateInfo, descriptor_set_count), offset_of!(DescriptorSetAllocateInfo, p_set_layouts));
    println!("SpecializationMapEntry {} {} {} {} {}", size_of::<SpecializationMapEntry>(), align_of::<SpecializationMapEntry>(), offset_of!(SpecializationMapEntry, constant_id), offset_of!(SpecializationMapEntry, offset), offset_of!(SpecializationMapEntry, size));
    println!("SpecializationInfo {} {} {} {} {} {}", size_of::<SpecializationInfo>(), align_of::<SpecializationInfo>(), offset_of!(SpecializationInfo, map_entry_count), offset_of!(SpecializationInfo, p_map_entries), offset_of!(SpecializationInfo, data_size), offset_of!(SpecializationInfo, p_data));
    println!("PipelineShaderStageCreateInfo {} {} {} {} {} {} {} {} {} {}", size_of::<PipelineShaderStageCreateInfo>(), align_of::<PipelineShaderStageCreateInfo>(), offset_of!(PipelineShaderStageCreateInfo, s_type), offset_of!(PipelineShaderStageCreateInfo, p_next), offset_of!(PipelineShaderStageCreateInfo, flags), offset_of!(PipelineShaderStageCreateInfo, stage), offset_of!(PipelineShaderStageCreateInfo, module), offset_of!(PipelineShaderStageCreateInfo, p_name), offset_of!(PipelineShaderStageCreateInfo, p_name), offset_of!(PipelineShaderStageCreateInfo, p_specialization_info));
    println!("ComputePipelineCreateInfo {} {} {} {} {} {} {} {} {}", size_of::<ComputePipelineCreateInfo>(), align_of::<ComputePipelineCreateInfo>(), offset_of!(ComputePipelineCreateInfo, s_type), offset_of!(ComputePipelineCreateInfo, p_next), offset_of!(ComputePipelineCreateInfo, flags), offset_of!(ComputePipelineCreateInfo, stage), offset_of!(ComputePipelineCreateInfo, layout), offset_of!(ComputePipelineCreateInfo, base_pipeline_handle), offset_of!(ComputePipelineCreateInfo, base_pipeline_index));
    println!("ComputePipelineIndirectBufferInfoNV {} {} {} {} {} {} {}", size_of::<ComputePipelineIndirectBufferInfoNV>(), align_of::<ComputePipelineIndirectBufferInfoNV>(), offset_of!(ComputePipelineIndirectBufferInfoNV, s_type), offset_of!(ComputePipelineIndirectBufferInfoNV, p_next), offset_of!(ComputePipelineIndirectBufferInfoNV, device_address), offset_of!(ComputePipelineIndirectBufferInfoNV, size), offset_of!(ComputePipelineIndirectBufferInfoNV, pipeline_device_address_capture_replay));
    println!("PipelineCreateFlags2CreateInfo {} {} {} {} {}", size_of::<PipelineCreateFlags2CreateInfo>(), align_of::<PipelineCreateFlags2CreateInfo>(), offset_of!(PipelineCreateFlags2CreateInfo, s_type), offset_of!(PipelineCreateFlags2CreateInfo, p_next), offset_of!(PipelineCreateFlags2CreateInfo, flags));
    println!("VertexInputBindingDescription {} {} {} {} {}", size_of::<VertexInputBindingDescription>(), align_of::<VertexInputBindingDescription>(), offset_of!(VertexInputBindingDescription, binding), offset_of!(VertexInputBindingDescription, stride), offset_of!(VertexInputBindingDescription, input_rate));
    println!("VertexInputAttributeDescription {} {} {} {} {} {}", size_of::<VertexInputAttributeDescription>(), align_of::<VertexInputAttributeDescription>(), offset_of!(VertexInputAttributeDescription, location), offset_of!(VertexInputAttributeDescription, binding), offset_of!(VertexInputAttributeDescription, format), offset_of!(VertexInputAttributeDescription, offset));
    println!("PipelineVertexInputStateCreateInfo {} {} {} {} {} {} {} {} {}", size_of::<PipelineVertexInputStateCreateInfo>(), align_of::<PipelineVertexInputStateCreateInfo>(), offset_of!(PipelineVertexInputStateCreateInfo, s_type), offset_of!(PipelineVertexInputStateCreateInfo, p_next), offset_of!(PipelineVertexInputStateCreateInfo, flags), offset_of!(PipelineVertexInputStateCreateInfo, vertex_binding_description_count), offset_of!(PipelineVertexInputStateCreateInfo, p_vertex_binding_descriptions), offset_of!(PipelineVertexInputStateCreateInfo, vertex_attribute_description_count), offset_of!(PipelineVertexInputStateCreateInfo, p_vertex_attribute_descriptions));
    println!("PipelineInputAssemblyStateCreateInfo {} {} {} {} {} {} {}", size_of::<PipelineInputAssemblyStateCreateInfo>(), align_of::<PipelineInputAssemblyStateCreateInfo>(), offset_of!(PipelineInputAssemblyStateCreateInfo, s_type), offset_of!(PipelineInputAssemblyStateCreateInfo, p_next), offset_of!(PipelineInputAssemblyStateCreateInfo, flags), offset_of!(PipelineInputAssemblyStateCreateInfo, topology), offset_of!(PipelineInputAssemblyStateCreateInfo, primitive_restart_enable));
    println!("PipelineTessellationStateCreateInfo {} {} {} {} {} {}", size_of::<PipelineTessellationStateCreateInfo>(), align_of::<PipelineTessellationStateCreateInfo>(), offset_of!(PipelineTessellationStateCreateInfo, s_type), offset_of!(PipelineTessellationStateCreateInfo, p_next), offset_of!(PipelineTessellationStateCreateInfo, flags), offset_of!(PipelineTessellationStateCreateInfo, patch_control_points));
    println!("PipelineViewportStateCreateInfo {} {} {} {} {} {} {} {} {}", size_of::<PipelineViewportStateCreateInfo>(), align_of::<PipelineViewportStateCreateInfo>(), offset_of!(PipelineViewportStateCreateInfo, s_type), offset_of!(PipelineViewportStateCreateInfo, p_next), offset_of!(PipelineViewportStateCreateInfo, flags), offset_of!(PipelineViewportStateCreateInfo, viewport_count), offset_of!(PipelineViewportStateCreateInfo, p_viewports), offset_of!(PipelineViewportStateCreateInfo, scissor_count), offset_of!(PipelineViewportStateCreateInfo, p_scissors));
    println!("PipelineRasterizationStateCreateInfo {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PipelineRasterizationStateCreateInfo>(), align_of::<PipelineRasterizationStateCreateInfo>(), offset_of!(PipelineRasterizationStateCreateInfo, s_type), offset_of!(PipelineRasterizationStateCreateInfo, p_next), offset_of!(PipelineRasterizationStateCreateInfo, flags), offset_of!(PipelineRasterizationStateCreateInfo, depth_clamp_enable), offset_of!(PipelineRasterizationStateCreateInfo, rasterizer_discard_enable), offset_of!(PipelineRasterizationStateCreateInfo, polygon_mode), offset_of!(PipelineRasterizationStateCreateInfo, cull_mode), offset_of!(PipelineRasterizationStateCreateInfo, front_face), offset_of!(PipelineRasterizationStateCreateInfo, depth_bias_enable), offset_of!(PipelineRasterizationStateCreateInfo, depth_bias_constant_factor), offset_of!(PipelineRasterizationStateCreateInfo, depth_bias_clamp), offset_of!(PipelineRasterizationStateCreateInfo, depth_bias_slope_factor), offset_of!(PipelineRasterizationStateCreateInfo, line_width));
    println!("PipelineMultisampleStateCreateInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<PipelineMultisampleStateCreateInfo>(), align_of::<PipelineMultisampleStateCreateInfo>(), offset_of!(PipelineMultisampleStateCreateInfo, s_type), offset_of!(PipelineMultisampleStateCreateInfo, p_next), offset_of!(PipelineMultisampleStateCreateInfo, flags), offset_of!(PipelineMultisampleStateCreateInfo, rasterization_samples), offset_of!(PipelineMultisampleStateCreateInfo, sample_shading_enable), offset_of!(PipelineMultisampleStateCreateInfo, min_sample_shading), offset_of!(PipelineMultisampleStateCreateInfo, p_sample_mask), offset_of!(PipelineMultisampleStateCreateInfo, alpha_to_coverage_enable), offset_of!(PipelineMultisampleStateCreateInfo, alpha_to_one_enable));
    println!("PipelineColorBlendAttachmentState {} {} {} {} {} {} {} {} {} {}", size_of::<PipelineColorBlendAttachmentState>(), align_of::<PipelineColorBlendAttachmentState>(), offset_of!(PipelineColorBlendAttachmentState, blend_enable), offset_of!(PipelineColorBlendAttachmentState, src_color_blend_factor), offset_of!(PipelineColorBlendAttachmentState, dst_color_blend_factor), offset_of!(PipelineColorBlendAttachmentState, color_blend_op), offset_of!(PipelineColorBlendAttachmentState, src_alpha_blend_factor), offset_of!(PipelineColorBlendAttachmentState, dst_alpha_blend_factor), offset_of!(PipelineColorBlendAttachmentState, alpha_blend_op), offset_of!(PipelineColorBlendAttachmentState, color_write_mask));
    println!("PipelineColorBlendStateCreateInfo {} {} {} {} {} {} {} {} {} {}", size_of::<PipelineColorBlendStateCreateInfo>(), align_of::<PipelineColorBlendStateCreateInfo>(), offset_of!(PipelineColorBlendStateCreateInfo, s_type), offset_of!(PipelineColorBlendStateCreateInfo, p_next), offset_of!(PipelineColorBlendStateCreateInfo, flags), offset_of!(PipelineColorBlendStateCreateInfo, logic_op_enable), offset_of!(PipelineColorBlendStateCreateInfo, logic_op), offset_of!(PipelineColorBlendStateCreateInfo, attachment_count), offset_of!(PipelineColorBlendStateCreateInfo, p_attachments), offset_of!(PipelineColorBlendStateCreateInfo, blend_constants));
    println!("PipelineDynamicStateCreateInfo {} {} {} {} {} {} {}", size_of::<PipelineDynamicStateCreateInfo>(), align_of::<PipelineDynamicStateCreateInfo>(), offset_of!(PipelineDynamicStateCreateInfo, s_type), offset_of!(PipelineDynamicStateCreateInfo, p_next), offset_of!(PipelineDynamicStateCreateInfo, flags), offset_of!(PipelineDynamicStateCreateInfo, dynamic_state_count), offset_of!(PipelineDynamicStateCreateInfo, p_dynamic_states));
    println!("StencilOpState {} {} {} {} {} {} {} {} {}", size_of::<StencilOpState>(), align_of::<StencilOpState>(), offset_of!(StencilOpState, fail_op), offset_of!(StencilOpState, pass_op), offset_of!(StencilOpState, depth_fail_op), offset_of!(StencilOpState, compare_op), offset_of!(StencilOpState, compare_mask), offset_of!(StencilOpState, write_mask), offset_of!(StencilOpState, reference));
    println!("PipelineDepthStencilStateCreateInfo {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PipelineDepthStencilStateCreateInfo>(), align_of::<PipelineDepthStencilStateCreateInfo>(), offset_of!(PipelineDepthStencilStateCreateInfo, s_type), offset_of!(PipelineDepthStencilStateCreateInfo, p_next), offset_of!(PipelineDepthStencilStateCreateInfo, flags), offset_of!(PipelineDepthStencilStateCreateInfo, depth_test_enable), offset_of!(PipelineDepthStencilStateCreateInfo, depth_write_enable), offset_of!(PipelineDepthStencilStateCreateInfo, depth_compare_op), offset_of!(PipelineDepthStencilStateCreateInfo, depth_bounds_test_enable), offset_of!(PipelineDepthStencilStateCreateInfo, stencil_test_enable), offset_of!(PipelineDepthStencilStateCreateInfo, front), offset_of!(PipelineDepthStencilStateCreateInfo, back), offset_of!(PipelineDepthStencilStateCreateInfo, min_depth_bounds), offset_of!(PipelineDepthStencilStateCreateInfo, max_depth_bounds));
    println!("GraphicsPipelineCreateInfo {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<GraphicsPipelineCreateInfo>(), align_of::<GraphicsPipelineCreateInfo>(), offset_of!(GraphicsPipelineCreateInfo, s_type), offset_of!(GraphicsPipelineCreateInfo, p_next), offset_of!(GraphicsPipelineCreateInfo, flags), offset_of!(GraphicsPipelineCreateInfo, stage_count), offset_of!(GraphicsPipelineCreateInfo, p_stages), offset_of!(GraphicsPipelineCreateInfo, p_stages), offset_of!(GraphicsPipelineCreateInfo, p_vertex_input_state), offset_of!(GraphicsPipelineCreateInfo, p_input_assembly_state), offset_of!(GraphicsPipelineCreateInfo, p_tessellation_state), offset_of!(GraphicsPipelineCreateInfo, p_viewport_state), offset_of!(GraphicsPipelineCreateInfo, p_rasterization_state), offset_of!(GraphicsPipelineCreateInfo, p_multisample_state), offset_of!(GraphicsPipelineCreateInfo, p_depth_stencil_state), offset_of!(GraphicsPipelineCreateInfo, p_color_blend_state), offset_of!(GraphicsPipelineCreateInfo, p_dynamic_state), offset_of!(GraphicsPipelineCreateInfo, layout), offset_of!(GraphicsPipelineCreateInfo, render_pass), offset_of!(GraphicsPipelineCreateInfo, subpass), offset_of!(GraphicsPipelineCreateInfo, base_pipeline_handle), offset_of!(GraphicsPipelineCreateInfo, base_pipeline_index));
    println!("PipelineCacheCreateInfo {} {} {} {} {} {} {} {}", size_of::<PipelineCacheCreateInfo>(), align_of::<PipelineCacheCreateInfo>(), offset_of!(PipelineCacheCreateInfo, s_type), offset_of!(PipelineCacheCreateInfo, p_next), offset_of!(PipelineCacheCreateInfo, flags), offset_of!(PipelineCacheCreateInfo, initial_data_size), offset_of!(PipelineCacheCreateInfo, initial_data_size), offset_of!(PipelineCacheCreateInfo, p_initial_data));
    println!("PipelineCacheHeaderVersionOne {} {} {} {} {} {} {}", size_of::<PipelineCacheHeaderVersionOne>(), align_of::<PipelineCacheHeaderVersionOne>(), offset_of!(PipelineCacheHeaderVersionOne, header_size), offset_of!(PipelineCacheHeaderVersionOne, header_version), offset_of!(PipelineCacheHeaderVersionOne, vendor_id), offset_of!(PipelineCacheHeaderVersionOne, device_id), offset_of!(PipelineCacheHeaderVersionOne, pipeline_cache_uuid));
    println!("PipelineCacheHeaderVersionDataGraphQCOM {} {} {} {} {} {} {}", size_of::<PipelineCacheHeaderVersionDataGraphQCOM>(), align_of::<PipelineCacheHeaderVersionDataGraphQCOM>(), offset_of!(PipelineCacheHeaderVersionDataGraphQCOM, header_size), offset_of!(PipelineCacheHeaderVersionDataGraphQCOM, header_version), offset_of!(PipelineCacheHeaderVersionDataGraphQCOM, cache_type), offset_of!(PipelineCacheHeaderVersionDataGraphQCOM, cache_version), offset_of!(PipelineCacheHeaderVersionDataGraphQCOM, toolchain_version));
    println!("PushConstantRange {} {} {} {} {}", size_of::<PushConstantRange>(), align_of::<PushConstantRange>(), offset_of!(PushConstantRange, stage_flags), offset_of!(PushConstantRange, offset), offset_of!(PushConstantRange, size));
    println!("PipelineBinaryCreateInfoKHR {} {} {} {} {} {} {}", size_of::<PipelineBinaryCreateInfoKHR>(), align_of::<PipelineBinaryCreateInfoKHR>(), offset_of!(PipelineBinaryCreateInfoKHR, s_type), offset_of!(PipelineBinaryCreateInfoKHR, p_next), offset_of!(PipelineBinaryCreateInfoKHR, p_keys_and_data_info), offset_of!(PipelineBinaryCreateInfoKHR, pipeline), offset_of!(PipelineBinaryCreateInfoKHR, p_pipeline_create_info));
    println!("PipelineBinaryHandlesInfoKHR {} {} {} {} {} {}", size_of::<PipelineBinaryHandlesInfoKHR>(), align_of::<PipelineBinaryHandlesInfoKHR>(), offset_of!(PipelineBinaryHandlesInfoKHR, s_type), offset_of!(PipelineBinaryHandlesInfoKHR, p_next), offset_of!(PipelineBinaryHandlesInfoKHR, pipeline_binary_count), offset_of!(PipelineBinaryHandlesInfoKHR, p_pipeline_binaries));
    println!("PipelineBinaryDataKHR {} {} {} {}", size_of::<PipelineBinaryDataKHR>(), align_of::<PipelineBinaryDataKHR>(), offset_of!(PipelineBinaryDataKHR, data_size), offset_of!(PipelineBinaryDataKHR, p_data));
    println!("PipelineBinaryKeysAndDataKHR {} {} {} {} {}", size_of::<PipelineBinaryKeysAndDataKHR>(), align_of::<PipelineBinaryKeysAndDataKHR>(), offset_of!(PipelineBinaryKeysAndDataKHR, binary_count), offset_of!(PipelineBinaryKeysAndDataKHR, p_pipeline_binary_keys), offset_of!(PipelineBinaryKeysAndDataKHR, p_pipeline_binary_data));
    println!("PipelineBinaryKeyKHR {} {} {} {} {} {}", size_of::<PipelineBinaryKeyKHR>(), align_of::<PipelineBinaryKeyKHR>(), offset_of!(PipelineBinaryKeyKHR, s_type), offset_of!(PipelineBinaryKeyKHR, p_next), offset_of!(PipelineBinaryKeyKHR, key_size), offset_of!(PipelineBinaryKeyKHR, key));
    println!("PipelineBinaryInfoKHR {} {} {} {} {} {}", size_of::<PipelineBinaryInfoKHR>(), align_of::<PipelineBinaryInfoKHR>(), offset_of!(PipelineBinaryInfoKHR, s_type), offset_of!(PipelineBinaryInfoKHR, p_next), offset_of!(PipelineBinaryInfoKHR, binary_count), offset_of!(PipelineBinaryInfoKHR, p_pipeline_binaries));
    println!("ReleaseCapturedPipelineDataInfoKHR {} {} {} {} {}", size_of::<ReleaseCapturedPipelineDataInfoKHR>(), align_of::<ReleaseCapturedPipelineDataInfoKHR>(), offset_of!(ReleaseCapturedPipelineDataInfoKHR, s_type), offset_of!(ReleaseCapturedPipelineDataInfoKHR, p_next), offset_of!(ReleaseCapturedPipelineDataInfoKHR, pipeline));
    println!("PipelineBinaryDataInfoKHR {} {} {} {} {}", size_of::<PipelineBinaryDataInfoKHR>(), align_of::<PipelineBinaryDataInfoKHR>(), offset_of!(PipelineBinaryDataInfoKHR, s_type), offset_of!(PipelineBinaryDataInfoKHR, p_next), offset_of!(PipelineBinaryDataInfoKHR, pipeline_binary));
    println!("PipelineCreateInfoKHR {} {} {} {}", size_of::<PipelineCreateInfoKHR>(), align_of::<PipelineCreateInfoKHR>(), offset_of!(PipelineCreateInfoKHR, s_type), offset_of!(PipelineCreateInfoKHR, p_next));
    println!("PipelineLayoutCreateInfo {} {} {} {} {} {} {} {} {}", size_of::<PipelineLayoutCreateInfo>(), align_of::<PipelineLayoutCreateInfo>(), offset_of!(PipelineLayoutCreateInfo, s_type), offset_of!(PipelineLayoutCreateInfo, p_next), offset_of!(PipelineLayoutCreateInfo, flags), offset_of!(PipelineLayoutCreateInfo, set_layout_count), offset_of!(PipelineLayoutCreateInfo, p_set_layouts), offset_of!(PipelineLayoutCreateInfo, push_constant_range_count), offset_of!(PipelineLayoutCreateInfo, p_push_constant_ranges));
    println!("SamplerCreateInfo {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SamplerCreateInfo>(), align_of::<SamplerCreateInfo>(), offset_of!(SamplerCreateInfo, s_type), offset_of!(SamplerCreateInfo, p_next), offset_of!(SamplerCreateInfo, flags), offset_of!(SamplerCreateInfo, mag_filter), offset_of!(SamplerCreateInfo, min_filter), offset_of!(SamplerCreateInfo, mipmap_mode), offset_of!(SamplerCreateInfo, address_mode_u), offset_of!(SamplerCreateInfo, address_mode_v), offset_of!(SamplerCreateInfo, address_mode_w), offset_of!(SamplerCreateInfo, mip_lod_bias), offset_of!(SamplerCreateInfo, anisotropy_enable), offset_of!(SamplerCreateInfo, max_anisotropy), offset_of!(SamplerCreateInfo, compare_enable), offset_of!(SamplerCreateInfo, compare_op), offset_of!(SamplerCreateInfo, min_lod), offset_of!(SamplerCreateInfo, max_lod), offset_of!(SamplerCreateInfo, border_color), offset_of!(SamplerCreateInfo, unnormalized_coordinates));
    println!("CommandPoolCreateInfo {} {} {} {} {} {}", size_of::<CommandPoolCreateInfo>(), align_of::<CommandPoolCreateInfo>(), offset_of!(CommandPoolCreateInfo, s_type), offset_of!(CommandPoolCreateInfo, p_next), offset_of!(CommandPoolCreateInfo, flags), offset_of!(CommandPoolCreateInfo, queue_family_index));
    println!("CommandBufferAllocateInfo {} {} {} {} {} {} {}", size_of::<CommandBufferAllocateInfo>(), align_of::<CommandBufferAllocateInfo>(), offset_of!(CommandBufferAllocateInfo, s_type), offset_of!(CommandBufferAllocateInfo, p_next), offset_of!(CommandBufferAllocateInfo, command_pool), offset_of!(CommandBufferAllocateInfo, level), offset_of!(CommandBufferAllocateInfo, command_buffer_count));
    println!("CommandBufferInheritanceInfo {} {} {} {} {} {} {} {} {} {}", size_of::<CommandBufferInheritanceInfo>(), align_of::<CommandBufferInheritanceInfo>(), offset_of!(CommandBufferInheritanceInfo, s_type), offset_of!(CommandBufferInheritanceInfo, p_next), offset_of!(CommandBufferInheritanceInfo, render_pass), offset_of!(CommandBufferInheritanceInfo, subpass), offset_of!(CommandBufferInheritanceInfo, framebuffer), offset_of!(CommandBufferInheritanceInfo, occlusion_query_enable), offset_of!(CommandBufferInheritanceInfo, query_flags), offset_of!(CommandBufferInheritanceInfo, pipeline_statistics));
    println!("CommandBufferBeginInfo {} {} {} {} {} {}", size_of::<CommandBufferBeginInfo>(), align_of::<CommandBufferBeginInfo>(), offset_of!(CommandBufferBeginInfo, s_type), offset_of!(CommandBufferBeginInfo, p_next), offset_of!(CommandBufferBeginInfo, flags), offset_of!(CommandBufferBeginInfo, p_inheritance_info));
    println!("RenderPassBeginInfo {} {} {} {} {} {} {} {} {}", size_of::<RenderPassBeginInfo>(), align_of::<RenderPassBeginInfo>(), offset_of!(RenderPassBeginInfo, s_type), offset_of!(RenderPassBeginInfo, p_next), offset_of!(RenderPassBeginInfo, render_pass), offset_of!(RenderPassBeginInfo, framebuffer), offset_of!(RenderPassBeginInfo, render_area), offset_of!(RenderPassBeginInfo, clear_value_count), offset_of!(RenderPassBeginInfo, p_clear_values));
    println!("ClearColorValue {} {} {} {} {}", size_of::<ClearColorValue>(), align_of::<ClearColorValue>(), offset_of!(ClearColorValue, float32), offset_of!(ClearColorValue, int32), offset_of!(ClearColorValue, uint32));
    println!("ClearDepthStencilValue {} {} {} {}", size_of::<ClearDepthStencilValue>(), align_of::<ClearDepthStencilValue>(), offset_of!(ClearDepthStencilValue, depth), offset_of!(ClearDepthStencilValue, stencil));
    println!("ClearValue {} {} {} {}", size_of::<ClearValue>(), align_of::<ClearValue>(), offset_of!(ClearValue, color), offset_of!(ClearValue, depth_stencil));
    println!("ClearAttachment {} {} {} {} {}", size_of::<ClearAttachment>(), align_of::<ClearAttachment>(), offset_of!(ClearAttachment, aspect_mask), offset_of!(ClearAttachment, color_attachment), offset_of!(ClearAttachment, clear_value));
    println!("AttachmentDescription {} {} {} {} {} {} {} {} {} {} {}", size_of::<AttachmentDescription>(), align_of::<AttachmentDescription>(), offset_of!(AttachmentDescription, flags), offset_of!(AttachmentDescription, format), offset_of!(AttachmentDescription, samples), offset_of!(AttachmentDescription, load_op), offset_of!(AttachmentDescription, store_op), offset_of!(AttachmentDescription, stencil_load_op), offset_of!(AttachmentDescription, stencil_store_op), offset_of!(AttachmentDescription, initial_layout), offset_of!(AttachmentDescription, final_layout));
    println!("AttachmentReference {} {} {} {}", size_of::<AttachmentReference>(), align_of::<AttachmentReference>(), offset_of!(AttachmentReference, attachment), offset_of!(AttachmentReference, layout));
    println!("SubpassDescription {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SubpassDescription>(), align_of::<SubpassDescription>(), offset_of!(SubpassDescription, flags), offset_of!(SubpassDescription, pipeline_bind_point), offset_of!(SubpassDescription, input_attachment_count), offset_of!(SubpassDescription, p_input_attachments), offset_of!(SubpassDescription, color_attachment_count), offset_of!(SubpassDescription, p_color_attachments), offset_of!(SubpassDescription, p_resolve_attachments), offset_of!(SubpassDescription, p_depth_stencil_attachment), offset_of!(SubpassDescription, preserve_attachment_count), offset_of!(SubpassDescription, p_preserve_attachments));
    println!("SubpassDependency {} {} {} {} {} {} {} {} {}", size_of::<SubpassDependency>(), align_of::<SubpassDependency>(), offset_of!(SubpassDependency, src_subpass), offset_of!(SubpassDependency, dst_subpass), offset_of!(SubpassDependency, src_stage_mask), offset_of!(SubpassDependency, dst_stage_mask), offset_of!(SubpassDependency, src_access_mask), offset_of!(SubpassDependency, dst_access_mask), offset_of!(SubpassDependency, dependency_flags));
    println!("RenderPassCreateInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<RenderPassCreateInfo>(), align_of::<RenderPassCreateInfo>(), offset_of!(RenderPassCreateInfo, s_type), offset_of!(RenderPassCreateInfo, p_next), offset_of!(RenderPassCreateInfo, flags), offset_of!(RenderPassCreateInfo, attachment_count), offset_of!(RenderPassCreateInfo, p_attachments), offset_of!(RenderPassCreateInfo, subpass_count), offset_of!(RenderPassCreateInfo, p_subpasses), offset_of!(RenderPassCreateInfo, dependency_count), offset_of!(RenderPassCreateInfo, p_dependencies));
    println!("EventCreateInfo {} {} {} {} {}", size_of::<EventCreateInfo>(), align_of::<EventCreateInfo>(), offset_of!(EventCreateInfo, s_type), offset_of!(EventCreateInfo, p_next), offset_of!(EventCreateInfo, flags));
    println!("FenceCreateInfo {} {} {} {} {}", size_of::<FenceCreateInfo>(), align_of::<FenceCreateInfo>(), offset_of!(FenceCreateInfo, s_type), offset_of!(FenceCreateInfo, p_next), offset_of!(FenceCreateInfo, flags));
    println!("PhysicalDeviceFeatures {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFeatures>(), align_of::<PhysicalDeviceFeatures>(), offset_of!(PhysicalDeviceFeatures, robust_buffer_access), offset_of!(PhysicalDeviceFeatures, full_draw_index_uint32), offset_of!(PhysicalDeviceFeatures, image_cube_array), offset_of!(PhysicalDeviceFeatures, independent_blend), offset_of!(PhysicalDeviceFeatures, geometry_shader), offset_of!(PhysicalDeviceFeatures, tessellation_shader), offset_of!(PhysicalDeviceFeatures, sample_rate_shading), offset_of!(PhysicalDeviceFeatures, dual_src_blend), offset_of!(PhysicalDeviceFeatures, logic_op), offset_of!(PhysicalDeviceFeatures, multi_draw_indirect), offset_of!(PhysicalDeviceFeatures, draw_indirect_first_instance), offset_of!(PhysicalDeviceFeatures, depth_clamp), offset_of!(PhysicalDeviceFeatures, depth_bias_clamp), offset_of!(PhysicalDeviceFeatures, fill_mode_non_solid), offset_of!(PhysicalDeviceFeatures, depth_bounds), offset_of!(PhysicalDeviceFeatures, wide_lines), offset_of!(PhysicalDeviceFeatures, large_points), offset_of!(PhysicalDeviceFeatures, alpha_to_one), offset_of!(PhysicalDeviceFeatures, multi_viewport), offset_of!(PhysicalDeviceFeatures, sampler_anisotropy), offset_of!(PhysicalDeviceFeatures, texture_compression_etc2), offset_of!(PhysicalDeviceFeatures, texture_compression_astc_ldr), offset_of!(PhysicalDeviceFeatures, texture_compression_bc), offset_of!(PhysicalDeviceFeatures, occlusion_query_precise), offset_of!(PhysicalDeviceFeatures, pipeline_statistics_query), offset_of!(PhysicalDeviceFeatures, vertex_pipeline_stores_and_atomics), offset_of!(PhysicalDeviceFeatures, fragment_stores_and_atomics), offset_of!(PhysicalDeviceFeatures, shader_tessellation_and_geometry_point_size), offset_of!(PhysicalDeviceFeatures, shader_image_gather_extended), offset_of!(PhysicalDeviceFeatures, shader_storage_image_extended_formats), offset_of!(PhysicalDeviceFeatures, shader_storage_image_multisample), offset_of!(PhysicalDeviceFeatures, shader_storage_image_read_without_format), offset_of!(PhysicalDeviceFeatures, shader_storage_image_write_without_format), offset_of!(PhysicalDeviceFeatures, shader_uniform_buffer_array_dynamic_indexing), offset_of!(PhysicalDeviceFeatures, shader_sampled_image_array_dynamic_indexing), offset_of!(PhysicalDeviceFeatures, shader_storage_buffer_array_dynamic_indexing), offset_of!(PhysicalDeviceFeatures, shader_storage_image_array_dynamic_indexing), offset_of!(PhysicalDeviceFeatures, shader_clip_distance), offset_of!(PhysicalDeviceFeatures, shader_cull_distance), offset_of!(PhysicalDeviceFeatures, shader_float64), offset_of!(PhysicalDeviceFeatures, shader_int64), offset_of!(PhysicalDeviceFeatures, shader_int16), offset_of!(PhysicalDeviceFeatures, shader_resource_residency), offset_of!(PhysicalDeviceFeatures, shader_resource_min_lod), offset_of!(PhysicalDeviceFeatures, sparse_binding), offset_of!(PhysicalDeviceFeatures, sparse_residency_buffer), offset_of!(PhysicalDeviceFeatures, sparse_residency_image2_d), offset_of!(PhysicalDeviceFeatures, sparse_residency_image3_d), offset_of!(PhysicalDeviceFeatures, sparse_residency2_samples), offset_of!(PhysicalDeviceFeatures, sparse_residency4_samples), offset_of!(PhysicalDeviceFeatures, sparse_residency8_samples), offset_of!(PhysicalDeviceFeatures, sparse_residency16_samples), offset_of!(PhysicalDeviceFeatures, sparse_residency_aliased), offset_of!(PhysicalDeviceFeatures, variable_multisample_rate), offset_of!(PhysicalDeviceFeatures, inherited_queries));
    println!("PhysicalDeviceSparseProperties {} {} {} {} {} {} {}", size_of::<PhysicalDeviceSparseProperties>(), align_of::<PhysicalDeviceSparseProperties>(), offset_of!(PhysicalDeviceSparseProperties, residency_standard2_d_block_shape), offset_of!(PhysicalDeviceSparseProperties, residency_standard2_d_multisample_block_shape), offset_of!(PhysicalDeviceSparseProperties, residency_standard3_d_block_shape), offset_of!(PhysicalDeviceSparseProperties, residency_aligned_mip_size), offset_of!(PhysicalDeviceSparseProperties, residency_non_resident_strict));
    println!("PhysicalDeviceLimits {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceLimits>(), align_of::<PhysicalDeviceLimits>(), offset_of!(PhysicalDeviceLimits, max_image_dimension1_d), offset_of!(PhysicalDeviceLimits, max_image_dimension2_d), offset_of!(PhysicalDeviceLimits, max_image_dimension3_d), offset_of!(PhysicalDeviceLimits, max_image_dimension_cube), offset_of!(PhysicalDeviceLimits, max_image_array_layers), offset_of!(PhysicalDeviceLimits, max_texel_buffer_elements), offset_of!(PhysicalDeviceLimits, max_uniform_buffer_range), offset_of!(PhysicalDeviceLimits, max_storage_buffer_range), offset_of!(PhysicalDeviceLimits, max_push_constants_size), offset_of!(PhysicalDeviceLimits, max_memory_allocation_count), offset_of!(PhysicalDeviceLimits, max_sampler_allocation_count), offset_of!(PhysicalDeviceLimits, buffer_image_granularity), offset_of!(PhysicalDeviceLimits, sparse_address_space_size), offset_of!(PhysicalDeviceLimits, max_bound_descriptor_sets), offset_of!(PhysicalDeviceLimits, max_per_stage_descriptor_samplers), offset_of!(PhysicalDeviceLimits, max_per_stage_descriptor_uniform_buffers), offset_of!(PhysicalDeviceLimits, max_per_stage_descriptor_storage_buffers), offset_of!(PhysicalDeviceLimits, max_per_stage_descriptor_sampled_images), offset_of!(PhysicalDeviceLimits, max_per_stage_descriptor_storage_images), offset_of!(PhysicalDeviceLimits, max_per_stage_descriptor_input_attachments), offset_of!(PhysicalDeviceLimits, max_per_stage_resources), offset_of!(PhysicalDeviceLimits, max_descriptor_set_samplers), offset_of!(PhysicalDeviceLimits, max_descriptor_set_uniform_buffers), offset_of!(PhysicalDeviceLimits, max_descriptor_set_uniform_buffers_dynamic), offset_of!(PhysicalDeviceLimits, max_descriptor_set_storage_buffers), offset_of!(PhysicalDeviceLimits, max_descriptor_set_storage_buffers_dynamic), offset_of!(PhysicalDeviceLimits, max_descriptor_set_sampled_images), offset_of!(PhysicalDeviceLimits, max_descriptor_set_storage_images), offset_of!(PhysicalDeviceLimits, max_descriptor_set_input_attachments), offset_of!(PhysicalDeviceLimits, max_vertex_input_attributes), offset_of!(PhysicalDeviceLimits, max_vertex_input_bindings), offset_of!(PhysicalDeviceLimits, max_vertex_input_attribute_offset), offset_of!(PhysicalDeviceLimits, max_vertex_input_binding_stride), offset_of!(PhysicalDeviceLimits, max_vertex_output_components), offset_of!(PhysicalDeviceLimits, max_tessellation_generation_level), offset_of!(PhysicalDeviceLimits, max_tessellation_patch_size), offset_of!(PhysicalDeviceLimits, max_tessellation_control_per_vertex_input_components), offset_of!(PhysicalDeviceLimits, max_tessellation_control_per_vertex_output_components), offset_of!(PhysicalDeviceLimits, max_tessellation_control_per_patch_output_components), offset_of!(PhysicalDeviceLimits, max_tessellation_control_total_output_components), offset_of!(PhysicalDeviceLimits, max_tessellation_evaluation_input_components), offset_of!(PhysicalDeviceLimits, max_tessellation_evaluation_output_components), offset_of!(PhysicalDeviceLimits, max_geometry_shader_invocations), offset_of!(PhysicalDeviceLimits, max_geometry_input_components), offset_of!(PhysicalDeviceLimits, max_geometry_output_components), offset_of!(PhysicalDeviceLimits, max_geometry_output_vertices), offset_of!(PhysicalDeviceLimits, max_geometry_total_output_components), offset_of!(PhysicalDeviceLimits, max_fragment_input_components), offset_of!(PhysicalDeviceLimits, max_fragment_output_attachments), offset_of!(PhysicalDeviceLimits, max_fragment_dual_src_attachments), offset_of!(PhysicalDeviceLimits, max_fragment_combined_output_resources), offset_of!(PhysicalDeviceLimits, max_compute_shared_memory_size), offset_of!(PhysicalDeviceLimits, max_compute_work_group_count), offset_of!(PhysicalDeviceLimits, max_compute_work_group_invocations), offset_of!(PhysicalDeviceLimits, max_compute_work_group_size), offset_of!(PhysicalDeviceLimits, sub_pixel_precision_bits), offset_of!(PhysicalDeviceLimits, sub_texel_precision_bits), offset_of!(PhysicalDeviceLimits, mipmap_precision_bits), offset_of!(PhysicalDeviceLimits, max_draw_indexed_index_value), offset_of!(PhysicalDeviceLimits, max_draw_indirect_count), offset_of!(PhysicalDeviceLimits, max_sampler_lod_bias), offset_of!(PhysicalDeviceLimits, max_sampler_anisotropy), offset_of!(PhysicalDeviceLimits, max_viewports), offset_of!(PhysicalDeviceLimits, max_viewport_dimensions), offset_of!(PhysicalDeviceLimits, viewport_bounds_range), offset_of!(PhysicalDeviceLimits, viewport_sub_pixel_bits), offset_of!(PhysicalDeviceLimits, min_memory_map_alignment), offset_of!(PhysicalDeviceLimits, min_texel_buffer_offset_alignment), offset_of!(PhysicalDeviceLimits, min_uniform_buffer_offset_alignment), offset_of!(PhysicalDeviceLimits, min_storage_buffer_offset_alignment), offset_of!(PhysicalDeviceLimits, min_texel_offset), offset_of!(PhysicalDeviceLimits, max_texel_offset), offset_of!(PhysicalDeviceLimits, min_texel_gather_offset), offset_of!(PhysicalDeviceLimits, max_texel_gather_offset), offset_of!(PhysicalDeviceLimits, min_interpolation_offset), offset_of!(PhysicalDeviceLimits, max_interpolation_offset), offset_of!(PhysicalDeviceLimits, sub_pixel_interpolation_offset_bits), offset_of!(PhysicalDeviceLimits, max_framebuffer_width), offset_of!(PhysicalDeviceLimits, max_framebuffer_height), offset_of!(PhysicalDeviceLimits, max_framebuffer_layers), offset_of!(PhysicalDeviceLimits, framebuffer_color_sample_counts), offset_of!(PhysicalDeviceLimits, framebuffer_depth_sample_counts), offset_of!(PhysicalDeviceLimits, framebuffer_stencil_sample_counts), offset_of!(PhysicalDeviceLimits, framebuffer_no_attachments_sample_counts), offset_of!(PhysicalDeviceLimits, max_color_attachments), offset_of!(PhysicalDeviceLimits, sampled_image_color_sample_counts), offset_of!(PhysicalDeviceLimits, sampled_image_integer_sample_counts), offset_of!(PhysicalDeviceLimits, sampled_image_depth_sample_counts), offset_of!(PhysicalDeviceLimits, sampled_image_stencil_sample_counts), offset_of!(PhysicalDeviceLimits, storage_image_sample_counts), offset_of!(PhysicalDeviceLimits, max_sample_mask_words), offset_of!(PhysicalDeviceLimits, timestamp_compute_and_graphics), offset_of!(PhysicalDeviceLimits, timestamp_period), offset_of!(PhysicalDeviceLimits, max_clip_distances), offset_of!(PhysicalDeviceLimits, max_cull_distances), offset_of!(PhysicalDeviceLimits, max_combined_clip_and_cull_distances), offset_of!(PhysicalDeviceLimits, discrete_queue_priorities), offset_of!(PhysicalDeviceLimits, point_size_range), offset_of!(PhysicalDeviceLimits, line_width_range), offset_of!(PhysicalDeviceLimits, point_size_granularity), offset_of!(PhysicalDeviceLimits, line_width_granularity), offset_of!(PhysicalDeviceLimits, strict_lines), offset_of!(PhysicalDeviceLimits, standard_sample_locations), offset_of!(PhysicalDeviceLimits, optimal_buffer_copy_offset_alignment), offset_of!(PhysicalDeviceLimits, optimal_buffer_copy_row_pitch_alignment), offset_of!(PhysicalDeviceLimits, non_coherent_atom_size));
    println!("SemaphoreCreateInfo {} {} {} {} {}", size_of::<SemaphoreCreateInfo>(), align_of::<SemaphoreCreateInfo>(), offset_of!(SemaphoreCreateInfo, s_type), offset_of!(SemaphoreCreateInfo, p_next), offset_of!(SemaphoreCreateInfo, flags));
    println!("QueryPoolCreateInfo {} {} {} {} {} {} {} {}", size_of::<QueryPoolCreateInfo>(), align_of::<QueryPoolCreateInfo>(), offset_of!(QueryPoolCreateInfo, s_type), offset_of!(QueryPoolCreateInfo, p_next), offset_of!(QueryPoolCreateInfo, flags), offset_of!(QueryPoolCreateInfo, query_type), offset_of!(QueryPoolCreateInfo, query_count), offset_of!(QueryPoolCreateInfo, pipeline_statistics));
    println!("FramebufferCreateInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<FramebufferCreateInfo>(), align_of::<FramebufferCreateInfo>(), offset_of!(FramebufferCreateInfo, s_type), offset_of!(FramebufferCreateInfo, p_next), offset_of!(FramebufferCreateInfo, flags), offset_of!(FramebufferCreateInfo, render_pass), offset_of!(FramebufferCreateInfo, attachment_count), offset_of!(FramebufferCreateInfo, p_attachments), offset_of!(FramebufferCreateInfo, width), offset_of!(FramebufferCreateInfo, height), offset_of!(FramebufferCreateInfo, layers));
    println!("DrawIndirectCommand {} {} {} {} {} {}", size_of::<DrawIndirectCommand>(), align_of::<DrawIndirectCommand>(), offset_of!(DrawIndirectCommand, vertex_count), offset_of!(DrawIndirectCommand, instance_count), offset_of!(DrawIndirectCommand, first_vertex), offset_of!(DrawIndirectCommand, first_instance));
    println!("DrawIndexedIndirectCommand {} {} {} {} {} {} {}", size_of::<DrawIndexedIndirectCommand>(), align_of::<DrawIndexedIndirectCommand>(), offset_of!(DrawIndexedIndirectCommand, index_count), offset_of!(DrawIndexedIndirectCommand, instance_count), offset_of!(DrawIndexedIndirectCommand, first_index), offset_of!(DrawIndexedIndirectCommand, vertex_offset), offset_of!(DrawIndexedIndirectCommand, first_instance));
    println!("DispatchIndirectCommand {} {} {} {} {}", size_of::<DispatchIndirectCommand>(), align_of::<DispatchIndirectCommand>(), offset_of!(DispatchIndirectCommand, x), offset_of!(DispatchIndirectCommand, y), offset_of!(DispatchIndirectCommand, z));
    println!("MultiDrawInfoEXT {} {} {} {}", size_of::<MultiDrawInfoEXT>(), align_of::<MultiDrawInfoEXT>(), offset_of!(MultiDrawInfoEXT, first_vertex), offset_of!(MultiDrawInfoEXT, vertex_count));
    println!("MultiDrawIndexedInfoEXT {} {} {} {} {}", size_of::<MultiDrawIndexedInfoEXT>(), align_of::<MultiDrawIndexedInfoEXT>(), offset_of!(MultiDrawIndexedInfoEXT, first_index), offset_of!(MultiDrawIndexedInfoEXT, index_count), offset_of!(MultiDrawIndexedInfoEXT, vertex_offset));
    println!("SubmitInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<SubmitInfo>(), align_of::<SubmitInfo>(), offset_of!(SubmitInfo, s_type), offset_of!(SubmitInfo, p_next), offset_of!(SubmitInfo, wait_semaphore_count), offset_of!(SubmitInfo, p_wait_semaphores), offset_of!(SubmitInfo, p_wait_dst_stage_mask), offset_of!(SubmitInfo, command_buffer_count), offset_of!(SubmitInfo, p_command_buffers), offset_of!(SubmitInfo, signal_semaphore_count), offset_of!(SubmitInfo, p_signal_semaphores));
    println!("DisplayPropertiesKHR {} {} {} {} {} {} {} {} {}", size_of::<DisplayPropertiesKHR>(), align_of::<DisplayPropertiesKHR>(), offset_of!(DisplayPropertiesKHR, display), offset_of!(DisplayPropertiesKHR, display_name), offset_of!(DisplayPropertiesKHR, physical_dimensions), offset_of!(DisplayPropertiesKHR, physical_resolution), offset_of!(DisplayPropertiesKHR, supported_transforms), offset_of!(DisplayPropertiesKHR, plane_reorder_possible), offset_of!(DisplayPropertiesKHR, persistent_content));
    println!("DisplayPlanePropertiesKHR {} {} {} {}", size_of::<DisplayPlanePropertiesKHR>(), align_of::<DisplayPlanePropertiesKHR>(), offset_of!(DisplayPlanePropertiesKHR, current_display), offset_of!(DisplayPlanePropertiesKHR, current_stack_index));
    println!("DisplayModeParametersKHR {} {} {} {}", size_of::<DisplayModeParametersKHR>(), align_of::<DisplayModeParametersKHR>(), offset_of!(DisplayModeParametersKHR, visible_region), offset_of!(DisplayModeParametersKHR, refresh_rate));
    println!("DisplayModePropertiesKHR {} {} {} {}", size_of::<DisplayModePropertiesKHR>(), align_of::<DisplayModePropertiesKHR>(), offset_of!(DisplayModePropertiesKHR, display_mode), offset_of!(DisplayModePropertiesKHR, parameters));
    println!("DisplayModeCreateInfoKHR {} {} {} {} {} {}", size_of::<DisplayModeCreateInfoKHR>(), align_of::<DisplayModeCreateInfoKHR>(), offset_of!(DisplayModeCreateInfoKHR, s_type), offset_of!(DisplayModeCreateInfoKHR, p_next), offset_of!(DisplayModeCreateInfoKHR, flags), offset_of!(DisplayModeCreateInfoKHR, parameters));
    println!("DisplayPlaneCapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {}", size_of::<DisplayPlaneCapabilitiesKHR>(), align_of::<DisplayPlaneCapabilitiesKHR>(), offset_of!(DisplayPlaneCapabilitiesKHR, supported_alpha), offset_of!(DisplayPlaneCapabilitiesKHR, min_src_position), offset_of!(DisplayPlaneCapabilitiesKHR, max_src_position), offset_of!(DisplayPlaneCapabilitiesKHR, min_src_extent), offset_of!(DisplayPlaneCapabilitiesKHR, max_src_extent), offset_of!(DisplayPlaneCapabilitiesKHR, min_dst_position), offset_of!(DisplayPlaneCapabilitiesKHR, max_dst_position), offset_of!(DisplayPlaneCapabilitiesKHR, min_dst_extent), offset_of!(DisplayPlaneCapabilitiesKHR, max_dst_extent));
    println!("DisplaySurfaceCreateInfoKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DisplaySurfaceCreateInfoKHR>(), align_of::<DisplaySurfaceCreateInfoKHR>(), offset_of!(DisplaySurfaceCreateInfoKHR, s_type), offset_of!(DisplaySurfaceCreateInfoKHR, p_next), offset_of!(DisplaySurfaceCreateInfoKHR, flags), offset_of!(DisplaySurfaceCreateInfoKHR, display_mode), offset_of!(DisplaySurfaceCreateInfoKHR, plane_index), offset_of!(DisplaySurfaceCreateInfoKHR, plane_stack_index), offset_of!(DisplaySurfaceCreateInfoKHR, transform), offset_of!(DisplaySurfaceCreateInfoKHR, global_alpha), offset_of!(DisplaySurfaceCreateInfoKHR, alpha_mode), offset_of!(DisplaySurfaceCreateInfoKHR, image_extent));
    println!("DisplaySurfaceStereoCreateInfoNV {} {} {} {} {}", size_of::<DisplaySurfaceStereoCreateInfoNV>(), align_of::<DisplaySurfaceStereoCreateInfoNV>(), offset_of!(DisplaySurfaceStereoCreateInfoNV, s_type), offset_of!(DisplaySurfaceStereoCreateInfoNV, p_next), offset_of!(DisplaySurfaceStereoCreateInfoNV, stereo_type));
    println!("DisplayPresentInfoKHR {} {} {} {} {} {} {}", size_of::<DisplayPresentInfoKHR>(), align_of::<DisplayPresentInfoKHR>(), offset_of!(DisplayPresentInfoKHR, s_type), offset_of!(DisplayPresentInfoKHR, p_next), offset_of!(DisplayPresentInfoKHR, src_rect), offset_of!(DisplayPresentInfoKHR, dst_rect), offset_of!(DisplayPresentInfoKHR, persistent));
    println!("SurfaceCapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SurfaceCapabilitiesKHR>(), align_of::<SurfaceCapabilitiesKHR>(), offset_of!(SurfaceCapabilitiesKHR, min_image_count), offset_of!(SurfaceCapabilitiesKHR, max_image_count), offset_of!(SurfaceCapabilitiesKHR, current_extent), offset_of!(SurfaceCapabilitiesKHR, min_image_extent), offset_of!(SurfaceCapabilitiesKHR, max_image_extent), offset_of!(SurfaceCapabilitiesKHR, max_image_array_layers), offset_of!(SurfaceCapabilitiesKHR, supported_transforms), offset_of!(SurfaceCapabilitiesKHR, current_transform), offset_of!(SurfaceCapabilitiesKHR, supported_composite_alpha), offset_of!(SurfaceCapabilitiesKHR, supported_usage_flags));
    println!("SurfaceFormatKHR {} {} {} {}", size_of::<SurfaceFormatKHR>(), align_of::<SurfaceFormatKHR>(), offset_of!(SurfaceFormatKHR, format), offset_of!(SurfaceFormatKHR, color_space));
    println!("SwapchainCreateInfoKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SwapchainCreateInfoKHR>(), align_of::<SwapchainCreateInfoKHR>(), offset_of!(SwapchainCreateInfoKHR, s_type), offset_of!(SwapchainCreateInfoKHR, p_next), offset_of!(SwapchainCreateInfoKHR, flags), offset_of!(SwapchainCreateInfoKHR, surface), offset_of!(SwapchainCreateInfoKHR, min_image_count), offset_of!(SwapchainCreateInfoKHR, image_format), offset_of!(SwapchainCreateInfoKHR, image_color_space), offset_of!(SwapchainCreateInfoKHR, image_extent), offset_of!(SwapchainCreateInfoKHR, image_array_layers), offset_of!(SwapchainCreateInfoKHR, image_usage), offset_of!(SwapchainCreateInfoKHR, image_sharing_mode), offset_of!(SwapchainCreateInfoKHR, queue_family_index_count), offset_of!(SwapchainCreateInfoKHR, p_queue_family_indices), offset_of!(SwapchainCreateInfoKHR, pre_transform), offset_of!(SwapchainCreateInfoKHR, composite_alpha), offset_of!(SwapchainCreateInfoKHR, present_mode), offset_of!(SwapchainCreateInfoKHR, clipped), offset_of!(SwapchainCreateInfoKHR, old_swapchain), offset_of!(SwapchainCreateInfoKHR, old_swapchain));
    println!("PresentInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<PresentInfoKHR>(), align_of::<PresentInfoKHR>(), offset_of!(PresentInfoKHR, s_type), offset_of!(PresentInfoKHR, p_next), offset_of!(PresentInfoKHR, wait_semaphore_count), offset_of!(PresentInfoKHR, p_wait_semaphores), offset_of!(PresentInfoKHR, swapchain_count), offset_of!(PresentInfoKHR, p_swapchains), offset_of!(PresentInfoKHR, p_image_indices), offset_of!(PresentInfoKHR, p_results));
    println!("DebugReportCallbackCreateInfoEXT {} {} {} {} {} {} {}", size_of::<DebugReportCallbackCreateInfoEXT>(), align_of::<DebugReportCallbackCreateInfoEXT>(), offset_of!(DebugReportCallbackCreateInfoEXT, s_type), offset_of!(DebugReportCallbackCreateInfoEXT, p_next), offset_of!(DebugReportCallbackCreateInfoEXT, flags), offset_of!(DebugReportCallbackCreateInfoEXT, pfn_callback), offset_of!(DebugReportCallbackCreateInfoEXT, p_user_data));
    println!("ValidationFlagsEXT {} {} {} {} {} {}", size_of::<ValidationFlagsEXT>(), align_of::<ValidationFlagsEXT>(), offset_of!(ValidationFlagsEXT, s_type), offset_of!(ValidationFlagsEXT, p_next), offset_of!(ValidationFlagsEXT, disabled_validation_check_count), offset_of!(ValidationFlagsEXT, p_disabled_validation_checks));
    println!("ValidationFeaturesEXT {} {} {} {} {} {} {} {}", size_of::<ValidationFeaturesEXT>(), align_of::<ValidationFeaturesEXT>(), offset_of!(ValidationFeaturesEXT, s_type), offset_of!(ValidationFeaturesEXT, p_next), offset_of!(ValidationFeaturesEXT, enabled_validation_feature_count), offset_of!(ValidationFeaturesEXT, p_enabled_validation_features), offset_of!(ValidationFeaturesEXT, disabled_validation_feature_count), offset_of!(ValidationFeaturesEXT, p_disabled_validation_features));
    println!("LayerSettingsCreateInfoEXT {} {} {} {} {} {}", size_of::<LayerSettingsCreateInfoEXT>(), align_of::<LayerSettingsCreateInfoEXT>(), offset_of!(LayerSettingsCreateInfoEXT, s_type), offset_of!(LayerSettingsCreateInfoEXT, p_next), offset_of!(LayerSettingsCreateInfoEXT, setting_count), offset_of!(LayerSettingsCreateInfoEXT, p_settings));
    println!("LayerSettingEXT {} {} {} {} {} {}", size_of::<LayerSettingEXT>(), align_of::<LayerSettingEXT>(), offset_of!(LayerSettingEXT, p_layer_name), offset_of!(LayerSettingEXT, p_setting_name), offset_of!(LayerSettingEXT, value_count), offset_of!(LayerSettingEXT, p_values));
    println!("PipelineRasterizationStateRasterizationOrderAMD {} {} {} {} {}", size_of::<PipelineRasterizationStateRasterizationOrderAMD>(), align_of::<PipelineRasterizationStateRasterizationOrderAMD>(), offset_of!(PipelineRasterizationStateRasterizationOrderAMD, s_type), offset_of!(PipelineRasterizationStateRasterizationOrderAMD, p_next), offset_of!(PipelineRasterizationStateRasterizationOrderAMD, rasterization_order));
    println!("DebugMarkerObjectNameInfoEXT {} {} {} {} {} {} {}", size_of::<DebugMarkerObjectNameInfoEXT>(), align_of::<DebugMarkerObjectNameInfoEXT>(), offset_of!(DebugMarkerObjectNameInfoEXT, s_type), offset_of!(DebugMarkerObjectNameInfoEXT, p_next), offset_of!(DebugMarkerObjectNameInfoEXT, object_type), offset_of!(DebugMarkerObjectNameInfoEXT, object), offset_of!(DebugMarkerObjectNameInfoEXT, p_object_name));
    println!("DebugMarkerObjectTagInfoEXT {} {} {} {} {} {} {} {} {}", size_of::<DebugMarkerObjectTagInfoEXT>(), align_of::<DebugMarkerObjectTagInfoEXT>(), offset_of!(DebugMarkerObjectTagInfoEXT, s_type), offset_of!(DebugMarkerObjectTagInfoEXT, p_next), offset_of!(DebugMarkerObjectTagInfoEXT, object_type), offset_of!(DebugMarkerObjectTagInfoEXT, object), offset_of!(DebugMarkerObjectTagInfoEXT, tag_name), offset_of!(DebugMarkerObjectTagInfoEXT, tag_size), offset_of!(DebugMarkerObjectTagInfoEXT, p_tag));
    println!("DebugMarkerMarkerInfoEXT {} {} {} {} {} {}", size_of::<DebugMarkerMarkerInfoEXT>(), align_of::<DebugMarkerMarkerInfoEXT>(), offset_of!(DebugMarkerMarkerInfoEXT, s_type), offset_of!(DebugMarkerMarkerInfoEXT, p_next), offset_of!(DebugMarkerMarkerInfoEXT, p_marker_name), offset_of!(DebugMarkerMarkerInfoEXT, color));
    println!("DedicatedAllocationImageCreateInfoNV {} {} {} {} {}", size_of::<DedicatedAllocationImageCreateInfoNV>(), align_of::<DedicatedAllocationImageCreateInfoNV>(), offset_of!(DedicatedAllocationImageCreateInfoNV, s_type), offset_of!(DedicatedAllocationImageCreateInfoNV, p_next), offset_of!(DedicatedAllocationImageCreateInfoNV, dedicated_allocation));
    println!("DedicatedAllocationBufferCreateInfoNV {} {} {} {} {}", size_of::<DedicatedAllocationBufferCreateInfoNV>(), align_of::<DedicatedAllocationBufferCreateInfoNV>(), offset_of!(DedicatedAllocationBufferCreateInfoNV, s_type), offset_of!(DedicatedAllocationBufferCreateInfoNV, p_next), offset_of!(DedicatedAllocationBufferCreateInfoNV, dedicated_allocation));
    println!("DedicatedAllocationMemoryAllocateInfoNV {} {} {} {} {} {}", size_of::<DedicatedAllocationMemoryAllocateInfoNV>(), align_of::<DedicatedAllocationMemoryAllocateInfoNV>(), offset_of!(DedicatedAllocationMemoryAllocateInfoNV, s_type), offset_of!(DedicatedAllocationMemoryAllocateInfoNV, p_next), offset_of!(DedicatedAllocationMemoryAllocateInfoNV, image), offset_of!(DedicatedAllocationMemoryAllocateInfoNV, buffer));
    println!("ExternalImageFormatPropertiesNV {} {} {} {} {} {}", size_of::<ExternalImageFormatPropertiesNV>(), align_of::<ExternalImageFormatPropertiesNV>(), offset_of!(ExternalImageFormatPropertiesNV, image_format_properties), offset_of!(ExternalImageFormatPropertiesNV, external_memory_features), offset_of!(ExternalImageFormatPropertiesNV, export_from_imported_handle_types), offset_of!(ExternalImageFormatPropertiesNV, compatible_handle_types));
    println!("ExternalMemoryImageCreateInfoNV {} {} {} {} {}", size_of::<ExternalMemoryImageCreateInfoNV>(), align_of::<ExternalMemoryImageCreateInfoNV>(), offset_of!(ExternalMemoryImageCreateInfoNV, s_type), offset_of!(ExternalMemoryImageCreateInfoNV, p_next), offset_of!(ExternalMemoryImageCreateInfoNV, handle_types));
    println!("ExportMemoryAllocateInfoNV {} {} {} {} {}", size_of::<ExportMemoryAllocateInfoNV>(), align_of::<ExportMemoryAllocateInfoNV>(), offset_of!(ExportMemoryAllocateInfoNV, s_type), offset_of!(ExportMemoryAllocateInfoNV, p_next), offset_of!(ExportMemoryAllocateInfoNV, handle_types));
    println!("PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>(), align_of::<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>(), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, s_type), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, p_next), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, device_generated_commands));
    println!("PushConstantBankInfoNV {} {} {} {} {}", size_of::<PushConstantBankInfoNV>(), align_of::<PushConstantBankInfoNV>(), offset_of!(PushConstantBankInfoNV, s_type), offset_of!(PushConstantBankInfoNV, p_next), offset_of!(PushConstantBankInfoNV, bank));
    println!("PhysicalDevicePushConstantBankFeaturesNV {} {} {} {} {}", size_of::<PhysicalDevicePushConstantBankFeaturesNV>(), align_of::<PhysicalDevicePushConstantBankFeaturesNV>(), offset_of!(PhysicalDevicePushConstantBankFeaturesNV, s_type), offset_of!(PhysicalDevicePushConstantBankFeaturesNV, p_next), offset_of!(PhysicalDevicePushConstantBankFeaturesNV, push_constant_bank));
    println!("PhysicalDevicePushConstantBankPropertiesNV {} {} {} {} {} {} {} {}", size_of::<PhysicalDevicePushConstantBankPropertiesNV>(), align_of::<PhysicalDevicePushConstantBankPropertiesNV>(), offset_of!(PhysicalDevicePushConstantBankPropertiesNV, s_type), offset_of!(PhysicalDevicePushConstantBankPropertiesNV, p_next), offset_of!(PhysicalDevicePushConstantBankPropertiesNV, max_graphics_push_constant_banks), offset_of!(PhysicalDevicePushConstantBankPropertiesNV, max_compute_push_constant_banks), offset_of!(PhysicalDevicePushConstantBankPropertiesNV, max_graphics_push_data_banks), offset_of!(PhysicalDevicePushConstantBankPropertiesNV, max_compute_push_data_banks));
    println!("PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(), align_of::<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(), offset_of!(PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, s_type), offset_of!(PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, p_next), offset_of!(PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, device_generated_compute), offset_of!(PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, device_generated_compute_pipelines), offset_of!(PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, device_generated_compute_capture_replay));
    println!("DevicePrivateDataCreateInfo {} {} {} {} {}", size_of::<DevicePrivateDataCreateInfo>(), align_of::<DevicePrivateDataCreateInfo>(), offset_of!(DevicePrivateDataCreateInfo, s_type), offset_of!(DevicePrivateDataCreateInfo, p_next), offset_of!(DevicePrivateDataCreateInfo, private_data_slot_request_count));
    println!("PrivateDataSlotCreateInfo {} {} {} {} {}", size_of::<PrivateDataSlotCreateInfo>(), align_of::<PrivateDataSlotCreateInfo>(), offset_of!(PrivateDataSlotCreateInfo, s_type), offset_of!(PrivateDataSlotCreateInfo, p_next), offset_of!(PrivateDataSlotCreateInfo, flags));
    println!("PhysicalDevicePrivateDataFeatures {} {} {} {} {}", size_of::<PhysicalDevicePrivateDataFeatures>(), align_of::<PhysicalDevicePrivateDataFeatures>(), offset_of!(PhysicalDevicePrivateDataFeatures, s_type), offset_of!(PhysicalDevicePrivateDataFeatures, p_next), offset_of!(PhysicalDevicePrivateDataFeatures, private_data));
    println!("PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>(), align_of::<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>(), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, s_type), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, p_next), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, max_graphics_shader_group_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, max_indirect_sequence_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, max_indirect_commands_token_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, max_indirect_commands_stream_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, max_indirect_commands_token_offset), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, max_indirect_commands_stream_stride), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, min_sequences_count_buffer_offset_alignment), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, min_sequences_index_buffer_offset_alignment), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, min_indirect_commands_buffer_offset_alignment));
    println!("PhysicalDeviceClusterAccelerationStructureFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceClusterAccelerationStructureFeaturesNV>(), align_of::<PhysicalDeviceClusterAccelerationStructureFeaturesNV>(), offset_of!(PhysicalDeviceClusterAccelerationStructureFeaturesNV, s_type), offset_of!(PhysicalDeviceClusterAccelerationStructureFeaturesNV, p_next), offset_of!(PhysicalDeviceClusterAccelerationStructureFeaturesNV, cluster_acceleration_structure));
    println!("PhysicalDeviceClusterAccelerationStructurePropertiesNV {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceClusterAccelerationStructurePropertiesNV>(), align_of::<PhysicalDeviceClusterAccelerationStructurePropertiesNV>(), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, s_type), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, p_next), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, max_vertices_per_cluster), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, max_triangles_per_cluster), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, cluster_scratch_byte_alignment), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, cluster_byte_alignment), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, cluster_template_byte_alignment), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, cluster_bottom_level_byte_alignment), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, cluster_template_bounds_byte_alignment), offset_of!(PhysicalDeviceClusterAccelerationStructurePropertiesNV, max_cluster_geometry_index));
    println!("StridedDeviceAddressNV {} {} {} {}", size_of::<StridedDeviceAddressNV>(), align_of::<StridedDeviceAddressNV>(), offset_of!(StridedDeviceAddressNV, start_address), offset_of!(StridedDeviceAddressNV, stride_in_bytes));
    println!("RayTracingPipelineClusterAccelerationStructureCreateInfoNV {} {} {} {} {}", size_of::<RayTracingPipelineClusterAccelerationStructureCreateInfoNV>(), align_of::<RayTracingPipelineClusterAccelerationStructureCreateInfoNV>(), offset_of!(RayTracingPipelineClusterAccelerationStructureCreateInfoNV, s_type), offset_of!(RayTracingPipelineClusterAccelerationStructureCreateInfoNV, p_next), offset_of!(RayTracingPipelineClusterAccelerationStructureCreateInfoNV, allow_cluster_acceleration_structure));
    println!("ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {} {}", size_of::<ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>(), align_of::<ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>());
    println!("ClusterAccelerationStructureMoveObjectsInfoNV {} {} {}", size_of::<ClusterAccelerationStructureMoveObjectsInfoNV>(), align_of::<ClusterAccelerationStructureMoveObjectsInfoNV>(), offset_of!(ClusterAccelerationStructureMoveObjectsInfoNV, src_acceleration_structure));
    println!("ClusterAccelerationStructureBuildClustersBottomLevelInfoNV {} {} {} {} {}", size_of::<ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>(), align_of::<ClusterAccelerationStructureBuildClustersBottomLevelInfoNV>(), offset_of!(ClusterAccelerationStructureBuildClustersBottomLevelInfoNV, cluster_references_count), offset_of!(ClusterAccelerationStructureBuildClustersBottomLevelInfoNV, cluster_references_stride), offset_of!(ClusterAccelerationStructureBuildClustersBottomLevelInfoNV, cluster_references));
    println!("ClusterAccelerationStructureGetTemplateIndicesInfoNV {} {} {}", size_of::<ClusterAccelerationStructureGetTemplateIndicesInfoNV>(), align_of::<ClusterAccelerationStructureGetTemplateIndicesInfoNV>(), offset_of!(ClusterAccelerationStructureGetTemplateIndicesInfoNV, cluster_template_address));
    println!("ClusterAccelerationStructureBuildTriangleClusterInfoNV {} {}", size_of::<ClusterAccelerationStructureBuildTriangleClusterInfoNV>(), align_of::<ClusterAccelerationStructureBuildTriangleClusterInfoNV>());
    println!("ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {} {}", size_of::<ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>(), align_of::<ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>());
    println!("ClusterAccelerationStructureInstantiateClusterInfoNV {} {}", size_of::<ClusterAccelerationStructureInstantiateClusterInfoNV>(), align_of::<ClusterAccelerationStructureInstantiateClusterInfoNV>());
    println!("ClusterAccelerationStructureClustersBottomLevelInputNV {} {} {} {} {} {}", size_of::<ClusterAccelerationStructureClustersBottomLevelInputNV>(), align_of::<ClusterAccelerationStructureClustersBottomLevelInputNV>(), offset_of!(ClusterAccelerationStructureClustersBottomLevelInputNV, s_type), offset_of!(ClusterAccelerationStructureClustersBottomLevelInputNV, p_next), offset_of!(ClusterAccelerationStructureClustersBottomLevelInputNV, max_total_cluster_count), offset_of!(ClusterAccelerationStructureClustersBottomLevelInputNV, max_cluster_count_per_acceleration_structure));
    println!("ClusterAccelerationStructureTriangleClusterInputNV {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ClusterAccelerationStructureTriangleClusterInputNV>(), align_of::<ClusterAccelerationStructureTriangleClusterInputNV>(), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, s_type), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, p_next), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, vertex_format), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, max_geometry_index_value), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, max_cluster_unique_geometry_count), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, max_cluster_triangle_count), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, max_cluster_vertex_count), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, max_total_triangle_count), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, max_total_vertex_count), offset_of!(ClusterAccelerationStructureTriangleClusterInputNV, min_position_truncate_bit_count));
    println!("ClusterAccelerationStructureMoveObjectsInputNV {} {} {} {} {} {}", size_of::<ClusterAccelerationStructureMoveObjectsInputNV>(), align_of::<ClusterAccelerationStructureMoveObjectsInputNV>(), offset_of!(ClusterAccelerationStructureMoveObjectsInputNV, s_type), offset_of!(ClusterAccelerationStructureMoveObjectsInputNV, p_next), offset_of!(ClusterAccelerationStructureMoveObjectsInputNV, no_move_overlap), offset_of!(ClusterAccelerationStructureMoveObjectsInputNV, max_moved_bytes));
    println!("ClusterAccelerationStructureOpInputNV {} {} {} {} {}", size_of::<ClusterAccelerationStructureOpInputNV>(), align_of::<ClusterAccelerationStructureOpInputNV>(), offset_of!(ClusterAccelerationStructureOpInputNV, p_clusters_bottom_level), offset_of!(ClusterAccelerationStructureOpInputNV, p_triangle_clusters), offset_of!(ClusterAccelerationStructureOpInputNV, p_move_objects));
    println!("ClusterAccelerationStructureInputInfoNV {} {} {} {} {} {} {} {} {}", size_of::<ClusterAccelerationStructureInputInfoNV>(), align_of::<ClusterAccelerationStructureInputInfoNV>(), offset_of!(ClusterAccelerationStructureInputInfoNV, s_type), offset_of!(ClusterAccelerationStructureInputInfoNV, p_next), offset_of!(ClusterAccelerationStructureInputInfoNV, max_acceleration_structure_count), offset_of!(ClusterAccelerationStructureInputInfoNV, flags), offset_of!(ClusterAccelerationStructureInputInfoNV, op_type), offset_of!(ClusterAccelerationStructureInputInfoNV, op_mode), offset_of!(ClusterAccelerationStructureInputInfoNV, op_input));
    println!("ClusterAccelerationStructureCommandsInfoNV {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ClusterAccelerationStructureCommandsInfoNV>(), align_of::<ClusterAccelerationStructureCommandsInfoNV>(), offset_of!(ClusterAccelerationStructureCommandsInfoNV, s_type), offset_of!(ClusterAccelerationStructureCommandsInfoNV, p_next), offset_of!(ClusterAccelerationStructureCommandsInfoNV, input), offset_of!(ClusterAccelerationStructureCommandsInfoNV, dst_implicit_data), offset_of!(ClusterAccelerationStructureCommandsInfoNV, scratch_data), offset_of!(ClusterAccelerationStructureCommandsInfoNV, dst_addresses_array), offset_of!(ClusterAccelerationStructureCommandsInfoNV, dst_sizes_array), offset_of!(ClusterAccelerationStructureCommandsInfoNV, src_infos_array), offset_of!(ClusterAccelerationStructureCommandsInfoNV, src_infos_count), offset_of!(ClusterAccelerationStructureCommandsInfoNV, address_resolution_flags));
    println!("PhysicalDeviceMultiDrawPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMultiDrawPropertiesEXT>(), align_of::<PhysicalDeviceMultiDrawPropertiesEXT>(), offset_of!(PhysicalDeviceMultiDrawPropertiesEXT, s_type), offset_of!(PhysicalDeviceMultiDrawPropertiesEXT, p_next), offset_of!(PhysicalDeviceMultiDrawPropertiesEXT, max_multi_draw_count));
    println!("GraphicsShaderGroupCreateInfoNV {} {} {} {} {} {} {} {}", size_of::<GraphicsShaderGroupCreateInfoNV>(), align_of::<GraphicsShaderGroupCreateInfoNV>(), offset_of!(GraphicsShaderGroupCreateInfoNV, s_type), offset_of!(GraphicsShaderGroupCreateInfoNV, p_next), offset_of!(GraphicsShaderGroupCreateInfoNV, stage_count), offset_of!(GraphicsShaderGroupCreateInfoNV, p_stages), offset_of!(GraphicsShaderGroupCreateInfoNV, p_vertex_input_state), offset_of!(GraphicsShaderGroupCreateInfoNV, p_tessellation_state));
    println!("GraphicsPipelineShaderGroupsCreateInfoNV {} {} {} {} {} {} {} {}", size_of::<GraphicsPipelineShaderGroupsCreateInfoNV>(), align_of::<GraphicsPipelineShaderGroupsCreateInfoNV>(), offset_of!(GraphicsPipelineShaderGroupsCreateInfoNV, s_type), offset_of!(GraphicsPipelineShaderGroupsCreateInfoNV, p_next), offset_of!(GraphicsPipelineShaderGroupsCreateInfoNV, group_count), offset_of!(GraphicsPipelineShaderGroupsCreateInfoNV, p_groups), offset_of!(GraphicsPipelineShaderGroupsCreateInfoNV, pipeline_count), offset_of!(GraphicsPipelineShaderGroupsCreateInfoNV, p_pipelines));
    println!("BindShaderGroupIndirectCommandNV {} {} {}", size_of::<BindShaderGroupIndirectCommandNV>(), align_of::<BindShaderGroupIndirectCommandNV>(), offset_of!(BindShaderGroupIndirectCommandNV, group_index));
    println!("BindIndexBufferIndirectCommandNV {} {} {} {} {}", size_of::<BindIndexBufferIndirectCommandNV>(), align_of::<BindIndexBufferIndirectCommandNV>(), offset_of!(BindIndexBufferIndirectCommandNV, buffer_address), offset_of!(BindIndexBufferIndirectCommandNV, size), offset_of!(BindIndexBufferIndirectCommandNV, index_type));
    println!("BindVertexBufferIndirectCommandNV {} {} {} {} {}", size_of::<BindVertexBufferIndirectCommandNV>(), align_of::<BindVertexBufferIndirectCommandNV>(), offset_of!(BindVertexBufferIndirectCommandNV, buffer_address), offset_of!(BindVertexBufferIndirectCommandNV, size), offset_of!(BindVertexBufferIndirectCommandNV, stride));
    println!("SetStateFlagsIndirectCommandNV {} {} {}", size_of::<SetStateFlagsIndirectCommandNV>(), align_of::<SetStateFlagsIndirectCommandNV>(), offset_of!(SetStateFlagsIndirectCommandNV, data));
    println!("IndirectCommandsStreamNV {} {} {} {}", size_of::<IndirectCommandsStreamNV>(), align_of::<IndirectCommandsStreamNV>(), offset_of!(IndirectCommandsStreamNV, buffer), offset_of!(IndirectCommandsStreamNV, offset));
    println!("IndirectCommandsLayoutTokenNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<IndirectCommandsLayoutTokenNV>(), align_of::<IndirectCommandsLayoutTokenNV>(), offset_of!(IndirectCommandsLayoutTokenNV, s_type), offset_of!(IndirectCommandsLayoutTokenNV, p_next), offset_of!(IndirectCommandsLayoutTokenNV, token_type), offset_of!(IndirectCommandsLayoutTokenNV, stream), offset_of!(IndirectCommandsLayoutTokenNV, offset), offset_of!(IndirectCommandsLayoutTokenNV, vertex_binding_unit), offset_of!(IndirectCommandsLayoutTokenNV, vertex_dynamic_stride), offset_of!(IndirectCommandsLayoutTokenNV, pushconstant_pipeline_layout), offset_of!(IndirectCommandsLayoutTokenNV, pushconstant_shader_stage_flags), offset_of!(IndirectCommandsLayoutTokenNV, pushconstant_offset), offset_of!(IndirectCommandsLayoutTokenNV, pushconstant_size), offset_of!(IndirectCommandsLayoutTokenNV, indirect_state_flags), offset_of!(IndirectCommandsLayoutTokenNV, index_type_count), offset_of!(IndirectCommandsLayoutTokenNV, p_index_types), offset_of!(IndirectCommandsLayoutTokenNV, p_index_type_values));
    println!("IndirectCommandsLayoutCreateInfoNV {} {} {} {} {} {} {} {} {} {}", size_of::<IndirectCommandsLayoutCreateInfoNV>(), align_of::<IndirectCommandsLayoutCreateInfoNV>(), offset_of!(IndirectCommandsLayoutCreateInfoNV, s_type), offset_of!(IndirectCommandsLayoutCreateInfoNV, p_next), offset_of!(IndirectCommandsLayoutCreateInfoNV, flags), offset_of!(IndirectCommandsLayoutCreateInfoNV, pipeline_bind_point), offset_of!(IndirectCommandsLayoutCreateInfoNV, token_count), offset_of!(IndirectCommandsLayoutCreateInfoNV, p_tokens), offset_of!(IndirectCommandsLayoutCreateInfoNV, stream_count), offset_of!(IndirectCommandsLayoutCreateInfoNV, p_stream_strides));
    println!("GeneratedCommandsInfoNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<GeneratedCommandsInfoNV>(), align_of::<GeneratedCommandsInfoNV>(), offset_of!(GeneratedCommandsInfoNV, s_type), offset_of!(GeneratedCommandsInfoNV, p_next), offset_of!(GeneratedCommandsInfoNV, pipeline_bind_point), offset_of!(GeneratedCommandsInfoNV, pipeline), offset_of!(GeneratedCommandsInfoNV, indirect_commands_layout), offset_of!(GeneratedCommandsInfoNV, stream_count), offset_of!(GeneratedCommandsInfoNV, p_streams), offset_of!(GeneratedCommandsInfoNV, sequences_count), offset_of!(GeneratedCommandsInfoNV, preprocess_buffer), offset_of!(GeneratedCommandsInfoNV, preprocess_offset), offset_of!(GeneratedCommandsInfoNV, preprocess_size), offset_of!(GeneratedCommandsInfoNV, sequences_count_buffer), offset_of!(GeneratedCommandsInfoNV, sequences_count_offset), offset_of!(GeneratedCommandsInfoNV, sequences_index_buffer), offset_of!(GeneratedCommandsInfoNV, sequences_index_offset));
    println!("GeneratedCommandsMemoryRequirementsInfoNV {} {} {} {} {} {} {} {}", size_of::<GeneratedCommandsMemoryRequirementsInfoNV>(), align_of::<GeneratedCommandsMemoryRequirementsInfoNV>(), offset_of!(GeneratedCommandsMemoryRequirementsInfoNV, s_type), offset_of!(GeneratedCommandsMemoryRequirementsInfoNV, p_next), offset_of!(GeneratedCommandsMemoryRequirementsInfoNV, pipeline_bind_point), offset_of!(GeneratedCommandsMemoryRequirementsInfoNV, pipeline), offset_of!(GeneratedCommandsMemoryRequirementsInfoNV, indirect_commands_layout), offset_of!(GeneratedCommandsMemoryRequirementsInfoNV, max_sequences_count));
    println!("PipelineIndirectDeviceAddressInfoNV {} {} {} {} {} {}", size_of::<PipelineIndirectDeviceAddressInfoNV>(), align_of::<PipelineIndirectDeviceAddressInfoNV>(), offset_of!(PipelineIndirectDeviceAddressInfoNV, s_type), offset_of!(PipelineIndirectDeviceAddressInfoNV, p_next), offset_of!(PipelineIndirectDeviceAddressInfoNV, pipeline_bind_point), offset_of!(PipelineIndirectDeviceAddressInfoNV, pipeline));
    println!("BindPipelineIndirectCommandNV {} {} {}", size_of::<BindPipelineIndirectCommandNV>(), align_of::<BindPipelineIndirectCommandNV>(), offset_of!(BindPipelineIndirectCommandNV, pipeline_address));
    println!("PhysicalDeviceFeatures2 {} {} {} {} {}", size_of::<PhysicalDeviceFeatures2>(), align_of::<PhysicalDeviceFeatures2>(), offset_of!(PhysicalDeviceFeatures2, s_type), offset_of!(PhysicalDeviceFeatures2, p_next), offset_of!(PhysicalDeviceFeatures2, features));
    println!("PhysicalDeviceProperties2 {} {} {} {} {}", size_of::<PhysicalDeviceProperties2>(), align_of::<PhysicalDeviceProperties2>(), offset_of!(PhysicalDeviceProperties2, s_type), offset_of!(PhysicalDeviceProperties2, p_next), offset_of!(PhysicalDeviceProperties2, properties));
    println!("FormatProperties2 {} {} {} {} {}", size_of::<FormatProperties2>(), align_of::<FormatProperties2>(), offset_of!(FormatProperties2, s_type), offset_of!(FormatProperties2, p_next), offset_of!(FormatProperties2, format_properties));
    println!("ImageFormatProperties2 {} {} {} {} {}", size_of::<ImageFormatProperties2>(), align_of::<ImageFormatProperties2>(), offset_of!(ImageFormatProperties2, s_type), offset_of!(ImageFormatProperties2, p_next), offset_of!(ImageFormatProperties2, image_format_properties));
    println!("PhysicalDeviceImageFormatInfo2 {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceImageFormatInfo2>(), align_of::<PhysicalDeviceImageFormatInfo2>(), offset_of!(PhysicalDeviceImageFormatInfo2, s_type), offset_of!(PhysicalDeviceImageFormatInfo2, p_next), offset_of!(PhysicalDeviceImageFormatInfo2, format), offset_of!(PhysicalDeviceImageFormatInfo2, tiling), offset_of!(PhysicalDeviceImageFormatInfo2, usage), offset_of!(PhysicalDeviceImageFormatInfo2, flags));
    println!("QueueFamilyProperties2 {} {} {} {} {}", size_of::<QueueFamilyProperties2>(), align_of::<QueueFamilyProperties2>(), offset_of!(QueueFamilyProperties2, s_type), offset_of!(QueueFamilyProperties2, p_next), offset_of!(QueueFamilyProperties2, queue_family_properties));
    println!("PhysicalDeviceMemoryProperties2 {} {} {} {} {}", size_of::<PhysicalDeviceMemoryProperties2>(), align_of::<PhysicalDeviceMemoryProperties2>(), offset_of!(PhysicalDeviceMemoryProperties2, s_type), offset_of!(PhysicalDeviceMemoryProperties2, p_next), offset_of!(PhysicalDeviceMemoryProperties2, memory_properties));
    println!("SparseImageFormatProperties2 {} {} {} {} {}", size_of::<SparseImageFormatProperties2>(), align_of::<SparseImageFormatProperties2>(), offset_of!(SparseImageFormatProperties2, s_type), offset_of!(SparseImageFormatProperties2, p_next), offset_of!(SparseImageFormatProperties2, properties));
    println!("PhysicalDeviceSparseImageFormatInfo2 {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceSparseImageFormatInfo2>(), align_of::<PhysicalDeviceSparseImageFormatInfo2>(), offset_of!(PhysicalDeviceSparseImageFormatInfo2, s_type), offset_of!(PhysicalDeviceSparseImageFormatInfo2, p_next), offset_of!(PhysicalDeviceSparseImageFormatInfo2, format), offset_of!(PhysicalDeviceSparseImageFormatInfo2, samples), offset_of!(PhysicalDeviceSparseImageFormatInfo2, usage), offset_of!(PhysicalDeviceSparseImageFormatInfo2, tiling));
    println!("PhysicalDevicePushDescriptorProperties {} {} {} {} {}", size_of::<PhysicalDevicePushDescriptorProperties>(), align_of::<PhysicalDevicePushDescriptorProperties>(), offset_of!(PhysicalDevicePushDescriptorProperties, s_type), offset_of!(PhysicalDevicePushDescriptorProperties, p_next), offset_of!(PhysicalDevicePushDescriptorProperties, max_push_descriptors));
    println!("ConformanceVersion {} {} {} {} {} {}", size_of::<ConformanceVersion>(), align_of::<ConformanceVersion>(), offset_of!(ConformanceVersion, major), offset_of!(ConformanceVersion, minor), offset_of!(ConformanceVersion, subminor), offset_of!(ConformanceVersion, patch));
    println!("PhysicalDeviceDriverProperties {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDriverProperties>(), align_of::<PhysicalDeviceDriverProperties>(), offset_of!(PhysicalDeviceDriverProperties, s_type), offset_of!(PhysicalDeviceDriverProperties, p_next), offset_of!(PhysicalDeviceDriverProperties, driver_id), offset_of!(PhysicalDeviceDriverProperties, driver_name), offset_of!(PhysicalDeviceDriverProperties, driver_info), offset_of!(PhysicalDeviceDriverProperties, conformance_version));
    println!("PresentRegionsKHR {} {} {} {} {} {}", size_of::<PresentRegionsKHR>(), align_of::<PresentRegionsKHR>(), offset_of!(PresentRegionsKHR, s_type), offset_of!(PresentRegionsKHR, p_next), offset_of!(PresentRegionsKHR, swapchain_count), offset_of!(PresentRegionsKHR, p_regions));
    println!("PresentRegionKHR {} {} {} {}", size_of::<PresentRegionKHR>(), align_of::<PresentRegionKHR>(), offset_of!(PresentRegionKHR, rectangle_count), offset_of!(PresentRegionKHR, p_rectangles));
    println!("RectLayerKHR {} {} {} {} {}", size_of::<RectLayerKHR>(), align_of::<RectLayerKHR>(), offset_of!(RectLayerKHR, offset), offset_of!(RectLayerKHR, extent), offset_of!(RectLayerKHR, layer));
    println!("PhysicalDeviceVariablePointersFeatures {} {} {} {} {} {}", size_of::<PhysicalDeviceVariablePointersFeatures>(), align_of::<PhysicalDeviceVariablePointersFeatures>(), offset_of!(PhysicalDeviceVariablePointersFeatures, s_type), offset_of!(PhysicalDeviceVariablePointersFeatures, p_next), offset_of!(PhysicalDeviceVariablePointersFeatures, variable_pointers_storage_buffer), offset_of!(PhysicalDeviceVariablePointersFeatures, variable_pointers));
    println!("ExternalMemoryProperties {} {} {} {} {}", size_of::<ExternalMemoryProperties>(), align_of::<ExternalMemoryProperties>(), offset_of!(ExternalMemoryProperties, external_memory_features), offset_of!(ExternalMemoryProperties, export_from_imported_handle_types), offset_of!(ExternalMemoryProperties, compatible_handle_types));
    println!("PhysicalDeviceExternalImageFormatInfo {} {} {} {} {}", size_of::<PhysicalDeviceExternalImageFormatInfo>(), align_of::<PhysicalDeviceExternalImageFormatInfo>(), offset_of!(PhysicalDeviceExternalImageFormatInfo, s_type), offset_of!(PhysicalDeviceExternalImageFormatInfo, p_next), offset_of!(PhysicalDeviceExternalImageFormatInfo, handle_type));
    println!("ExternalImageFormatProperties {} {} {} {} {}", size_of::<ExternalImageFormatProperties>(), align_of::<ExternalImageFormatProperties>(), offset_of!(ExternalImageFormatProperties, s_type), offset_of!(ExternalImageFormatProperties, p_next), offset_of!(ExternalImageFormatProperties, external_memory_properties));
    println!("PhysicalDeviceExternalBufferInfo {} {} {} {} {} {} {}", size_of::<PhysicalDeviceExternalBufferInfo>(), align_of::<PhysicalDeviceExternalBufferInfo>(), offset_of!(PhysicalDeviceExternalBufferInfo, s_type), offset_of!(PhysicalDeviceExternalBufferInfo, p_next), offset_of!(PhysicalDeviceExternalBufferInfo, flags), offset_of!(PhysicalDeviceExternalBufferInfo, usage), offset_of!(PhysicalDeviceExternalBufferInfo, handle_type));
    println!("ExternalBufferProperties {} {} {} {} {}", size_of::<ExternalBufferProperties>(), align_of::<ExternalBufferProperties>(), offset_of!(ExternalBufferProperties, s_type), offset_of!(ExternalBufferProperties, p_next), offset_of!(ExternalBufferProperties, external_memory_properties));
    println!("PhysicalDeviceIDProperties {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceIDProperties>(), align_of::<PhysicalDeviceIDProperties>(), offset_of!(PhysicalDeviceIDProperties, s_type), offset_of!(PhysicalDeviceIDProperties, p_next), offset_of!(PhysicalDeviceIDProperties, device_uuid), offset_of!(PhysicalDeviceIDProperties, driver_uuid), offset_of!(PhysicalDeviceIDProperties, device_luid), offset_of!(PhysicalDeviceIDProperties, device_node_mask), offset_of!(PhysicalDeviceIDProperties, device_luid_valid));
    println!("ExternalMemoryImageCreateInfo {} {} {} {} {}", size_of::<ExternalMemoryImageCreateInfo>(), align_of::<ExternalMemoryImageCreateInfo>(), offset_of!(ExternalMemoryImageCreateInfo, s_type), offset_of!(ExternalMemoryImageCreateInfo, p_next), offset_of!(ExternalMemoryImageCreateInfo, handle_types));
    println!("ExternalMemoryBufferCreateInfo {} {} {} {} {}", size_of::<ExternalMemoryBufferCreateInfo>(), align_of::<ExternalMemoryBufferCreateInfo>(), offset_of!(ExternalMemoryBufferCreateInfo, s_type), offset_of!(ExternalMemoryBufferCreateInfo, p_next), offset_of!(ExternalMemoryBufferCreateInfo, handle_types));
    println!("ExportMemoryAllocateInfo {} {} {} {} {}", size_of::<ExportMemoryAllocateInfo>(), align_of::<ExportMemoryAllocateInfo>(), offset_of!(ExportMemoryAllocateInfo, s_type), offset_of!(ExportMemoryAllocateInfo, p_next), offset_of!(ExportMemoryAllocateInfo, handle_types));
    println!("ImportMemoryFdInfoKHR {} {} {} {} {} {}", size_of::<ImportMemoryFdInfoKHR>(), align_of::<ImportMemoryFdInfoKHR>(), offset_of!(ImportMemoryFdInfoKHR, s_type), offset_of!(ImportMemoryFdInfoKHR, p_next), offset_of!(ImportMemoryFdInfoKHR, handle_type), offset_of!(ImportMemoryFdInfoKHR, fd));
    println!("MemoryFdPropertiesKHR {} {} {} {} {}", size_of::<MemoryFdPropertiesKHR>(), align_of::<MemoryFdPropertiesKHR>(), offset_of!(MemoryFdPropertiesKHR, s_type), offset_of!(MemoryFdPropertiesKHR, p_next), offset_of!(MemoryFdPropertiesKHR, memory_type_bits));
    println!("MemoryGetFdInfoKHR {} {} {} {} {} {}", size_of::<MemoryGetFdInfoKHR>(), align_of::<MemoryGetFdInfoKHR>(), offset_of!(MemoryGetFdInfoKHR, s_type), offset_of!(MemoryGetFdInfoKHR, p_next), offset_of!(MemoryGetFdInfoKHR, memory), offset_of!(MemoryGetFdInfoKHR, handle_type));
    println!("PhysicalDeviceExternalSemaphoreInfo {} {} {} {} {}", size_of::<PhysicalDeviceExternalSemaphoreInfo>(), align_of::<PhysicalDeviceExternalSemaphoreInfo>(), offset_of!(PhysicalDeviceExternalSemaphoreInfo, s_type), offset_of!(PhysicalDeviceExternalSemaphoreInfo, p_next), offset_of!(PhysicalDeviceExternalSemaphoreInfo, handle_type));
    println!("ExternalSemaphoreProperties {} {} {} {} {} {} {}", size_of::<ExternalSemaphoreProperties>(), align_of::<ExternalSemaphoreProperties>(), offset_of!(ExternalSemaphoreProperties, s_type), offset_of!(ExternalSemaphoreProperties, p_next), offset_of!(ExternalSemaphoreProperties, export_from_imported_handle_types), offset_of!(ExternalSemaphoreProperties, compatible_handle_types), offset_of!(ExternalSemaphoreProperties, external_semaphore_features));
    println!("ExportSemaphoreCreateInfo {} {} {} {} {}", size_of::<ExportSemaphoreCreateInfo>(), align_of::<ExportSemaphoreCreateInfo>(), offset_of!(ExportSemaphoreCreateInfo, s_type), offset_of!(ExportSemaphoreCreateInfo, p_next), offset_of!(ExportSemaphoreCreateInfo, handle_types));
    println!("ImportSemaphoreFdInfoKHR {} {} {} {} {} {} {} {}", size_of::<ImportSemaphoreFdInfoKHR>(), align_of::<ImportSemaphoreFdInfoKHR>(), offset_of!(ImportSemaphoreFdInfoKHR, s_type), offset_of!(ImportSemaphoreFdInfoKHR, p_next), offset_of!(ImportSemaphoreFdInfoKHR, semaphore), offset_of!(ImportSemaphoreFdInfoKHR, flags), offset_of!(ImportSemaphoreFdInfoKHR, handle_type), offset_of!(ImportSemaphoreFdInfoKHR, fd));
    println!("SemaphoreGetFdInfoKHR {} {} {} {} {} {}", size_of::<SemaphoreGetFdInfoKHR>(), align_of::<SemaphoreGetFdInfoKHR>(), offset_of!(SemaphoreGetFdInfoKHR, s_type), offset_of!(SemaphoreGetFdInfoKHR, p_next), offset_of!(SemaphoreGetFdInfoKHR, semaphore), offset_of!(SemaphoreGetFdInfoKHR, handle_type));
    println!("PhysicalDeviceExternalFenceInfo {} {} {} {} {}", size_of::<PhysicalDeviceExternalFenceInfo>(), align_of::<PhysicalDeviceExternalFenceInfo>(), offset_of!(PhysicalDeviceExternalFenceInfo, s_type), offset_of!(PhysicalDeviceExternalFenceInfo, p_next), offset_of!(PhysicalDeviceExternalFenceInfo, handle_type));
    println!("ExternalFenceProperties {} {} {} {} {} {} {}", size_of::<ExternalFenceProperties>(), align_of::<ExternalFenceProperties>(), offset_of!(ExternalFenceProperties, s_type), offset_of!(ExternalFenceProperties, p_next), offset_of!(ExternalFenceProperties, export_from_imported_handle_types), offset_of!(ExternalFenceProperties, compatible_handle_types), offset_of!(ExternalFenceProperties, external_fence_features));
    println!("ExportFenceCreateInfo {} {} {} {} {}", size_of::<ExportFenceCreateInfo>(), align_of::<ExportFenceCreateInfo>(), offset_of!(ExportFenceCreateInfo, s_type), offset_of!(ExportFenceCreateInfo, p_next), offset_of!(ExportFenceCreateInfo, handle_types));
    println!("ImportFenceFdInfoKHR {} {} {} {} {} {} {} {}", size_of::<ImportFenceFdInfoKHR>(), align_of::<ImportFenceFdInfoKHR>(), offset_of!(ImportFenceFdInfoKHR, s_type), offset_of!(ImportFenceFdInfoKHR, p_next), offset_of!(ImportFenceFdInfoKHR, fence), offset_of!(ImportFenceFdInfoKHR, flags), offset_of!(ImportFenceFdInfoKHR, handle_type), offset_of!(ImportFenceFdInfoKHR, fd));
    println!("FenceGetFdInfoKHR {} {} {} {} {} {}", size_of::<FenceGetFdInfoKHR>(), align_of::<FenceGetFdInfoKHR>(), offset_of!(FenceGetFdInfoKHR, s_type), offset_of!(FenceGetFdInfoKHR, p_next), offset_of!(FenceGetFdInfoKHR, fence), offset_of!(FenceGetFdInfoKHR, handle_type));
    println!("PhysicalDeviceMultiviewFeatures {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMultiviewFeatures>(), align_of::<PhysicalDeviceMultiviewFeatures>(), offset_of!(PhysicalDeviceMultiviewFeatures, s_type), offset_of!(PhysicalDeviceMultiviewFeatures, p_next), offset_of!(PhysicalDeviceMultiviewFeatures, multiview), offset_of!(PhysicalDeviceMultiviewFeatures, multiview_geometry_shader), offset_of!(PhysicalDeviceMultiviewFeatures, multiview_tessellation_shader));
    println!("PhysicalDeviceMultiviewProperties {} {} {} {} {} {}", size_of::<PhysicalDeviceMultiviewProperties>(), align_of::<PhysicalDeviceMultiviewProperties>(), offset_of!(PhysicalDeviceMultiviewProperties, s_type), offset_of!(PhysicalDeviceMultiviewProperties, p_next), offset_of!(PhysicalDeviceMultiviewProperties, max_multiview_view_count), offset_of!(PhysicalDeviceMultiviewProperties, max_multiview_instance_index));
    println!("RenderPassMultiviewCreateInfo {} {} {} {} {} {} {} {} {} {}", size_of::<RenderPassMultiviewCreateInfo>(), align_of::<RenderPassMultiviewCreateInfo>(), offset_of!(RenderPassMultiviewCreateInfo, s_type), offset_of!(RenderPassMultiviewCreateInfo, p_next), offset_of!(RenderPassMultiviewCreateInfo, subpass_count), offset_of!(RenderPassMultiviewCreateInfo, p_view_masks), offset_of!(RenderPassMultiviewCreateInfo, dependency_count), offset_of!(RenderPassMultiviewCreateInfo, p_view_offsets), offset_of!(RenderPassMultiviewCreateInfo, correlation_mask_count), offset_of!(RenderPassMultiviewCreateInfo, p_correlation_masks));
    println!("SurfaceCapabilities2EXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SurfaceCapabilities2EXT>(), align_of::<SurfaceCapabilities2EXT>(), offset_of!(SurfaceCapabilities2EXT, s_type), offset_of!(SurfaceCapabilities2EXT, p_next), offset_of!(SurfaceCapabilities2EXT, min_image_count), offset_of!(SurfaceCapabilities2EXT, max_image_count), offset_of!(SurfaceCapabilities2EXT, current_extent), offset_of!(SurfaceCapabilities2EXT, min_image_extent), offset_of!(SurfaceCapabilities2EXT, max_image_extent), offset_of!(SurfaceCapabilities2EXT, max_image_array_layers), offset_of!(SurfaceCapabilities2EXT, supported_transforms), offset_of!(SurfaceCapabilities2EXT, current_transform), offset_of!(SurfaceCapabilities2EXT, supported_composite_alpha), offset_of!(SurfaceCapabilities2EXT, supported_usage_flags), offset_of!(SurfaceCapabilities2EXT, supported_surface_counters));
    println!("DisplayPowerInfoEXT {} {} {} {} {}", size_of::<DisplayPowerInfoEXT>(), align_of::<DisplayPowerInfoEXT>(), offset_of!(DisplayPowerInfoEXT, s_type), offset_of!(DisplayPowerInfoEXT, p_next), offset_of!(DisplayPowerInfoEXT, power_state));
    println!("DeviceEventInfoEXT {} {} {} {} {}", size_of::<DeviceEventInfoEXT>(), align_of::<DeviceEventInfoEXT>(), offset_of!(DeviceEventInfoEXT, s_type), offset_of!(DeviceEventInfoEXT, p_next), offset_of!(DeviceEventInfoEXT, device_event));
    println!("DisplayEventInfoEXT {} {} {} {} {}", size_of::<DisplayEventInfoEXT>(), align_of::<DisplayEventInfoEXT>(), offset_of!(DisplayEventInfoEXT, s_type), offset_of!(DisplayEventInfoEXT, p_next), offset_of!(DisplayEventInfoEXT, display_event));
    println!("SwapchainCounterCreateInfoEXT {} {} {} {} {}", size_of::<SwapchainCounterCreateInfoEXT>(), align_of::<SwapchainCounterCreateInfoEXT>(), offset_of!(SwapchainCounterCreateInfoEXT, s_type), offset_of!(SwapchainCounterCreateInfoEXT, p_next), offset_of!(SwapchainCounterCreateInfoEXT, surface_counters));
    println!("PhysicalDeviceGroupProperties {} {} {} {} {} {} {}", size_of::<PhysicalDeviceGroupProperties>(), align_of::<PhysicalDeviceGroupProperties>(), offset_of!(PhysicalDeviceGroupProperties, s_type), offset_of!(PhysicalDeviceGroupProperties, p_next), offset_of!(PhysicalDeviceGroupProperties, physical_device_count), offset_of!(PhysicalDeviceGroupProperties, physical_devices), offset_of!(PhysicalDeviceGroupProperties, subset_allocation));
    println!("MemoryAllocateFlagsInfo {} {} {} {} {} {}", size_of::<MemoryAllocateFlagsInfo>(), align_of::<MemoryAllocateFlagsInfo>(), offset_of!(MemoryAllocateFlagsInfo, s_type), offset_of!(MemoryAllocateFlagsInfo, p_next), offset_of!(MemoryAllocateFlagsInfo, flags), offset_of!(MemoryAllocateFlagsInfo, device_mask));
    println!("BindBufferMemoryInfo {} {} {} {} {} {} {}", size_of::<BindBufferMemoryInfo>(), align_of::<BindBufferMemoryInfo>(), offset_of!(BindBufferMemoryInfo, s_type), offset_of!(BindBufferMemoryInfo, p_next), offset_of!(BindBufferMemoryInfo, buffer), offset_of!(BindBufferMemoryInfo, memory), offset_of!(BindBufferMemoryInfo, memory_offset));
    println!("BindBufferMemoryDeviceGroupInfo {} {} {} {} {} {}", size_of::<BindBufferMemoryDeviceGroupInfo>(), align_of::<BindBufferMemoryDeviceGroupInfo>(), offset_of!(BindBufferMemoryDeviceGroupInfo, s_type), offset_of!(BindBufferMemoryDeviceGroupInfo, p_next), offset_of!(BindBufferMemoryDeviceGroupInfo, device_index_count), offset_of!(BindBufferMemoryDeviceGroupInfo, p_device_indices));
    println!("BindImageMemoryInfo {} {} {} {} {} {} {}", size_of::<BindImageMemoryInfo>(), align_of::<BindImageMemoryInfo>(), offset_of!(BindImageMemoryInfo, s_type), offset_of!(BindImageMemoryInfo, p_next), offset_of!(BindImageMemoryInfo, image), offset_of!(BindImageMemoryInfo, memory), offset_of!(BindImageMemoryInfo, memory_offset));
    println!("BindImageMemoryDeviceGroupInfo {} {} {} {} {} {} {} {}", size_of::<BindImageMemoryDeviceGroupInfo>(), align_of::<BindImageMemoryDeviceGroupInfo>(), offset_of!(BindImageMemoryDeviceGroupInfo, s_type), offset_of!(BindImageMemoryDeviceGroupInfo, p_next), offset_of!(BindImageMemoryDeviceGroupInfo, device_index_count), offset_of!(BindImageMemoryDeviceGroupInfo, p_device_indices), offset_of!(BindImageMemoryDeviceGroupInfo, split_instance_bind_region_count), offset_of!(BindImageMemoryDeviceGroupInfo, p_split_instance_bind_regions));
    println!("DeviceGroupRenderPassBeginInfo {} {} {} {} {} {} {}", size_of::<DeviceGroupRenderPassBeginInfo>(), align_of::<DeviceGroupRenderPassBeginInfo>(), offset_of!(DeviceGroupRenderPassBeginInfo, s_type), offset_of!(DeviceGroupRenderPassBeginInfo, p_next), offset_of!(DeviceGroupRenderPassBeginInfo, device_mask), offset_of!(DeviceGroupRenderPassBeginInfo, device_render_area_count), offset_of!(DeviceGroupRenderPassBeginInfo, p_device_render_areas));
    println!("DeviceGroupCommandBufferBeginInfo {} {} {} {} {}", size_of::<DeviceGroupCommandBufferBeginInfo>(), align_of::<DeviceGroupCommandBufferBeginInfo>(), offset_of!(DeviceGroupCommandBufferBeginInfo, s_type), offset_of!(DeviceGroupCommandBufferBeginInfo, p_next), offset_of!(DeviceGroupCommandBufferBeginInfo, device_mask));
    println!("DeviceGroupSubmitInfo {} {} {} {} {} {} {} {} {} {}", size_of::<DeviceGroupSubmitInfo>(), align_of::<DeviceGroupSubmitInfo>(), offset_of!(DeviceGroupSubmitInfo, s_type), offset_of!(DeviceGroupSubmitInfo, p_next), offset_of!(DeviceGroupSubmitInfo, wait_semaphore_count), offset_of!(DeviceGroupSubmitInfo, p_wait_semaphore_device_indices), offset_of!(DeviceGroupSubmitInfo, command_buffer_count), offset_of!(DeviceGroupSubmitInfo, p_command_buffer_device_masks), offset_of!(DeviceGroupSubmitInfo, signal_semaphore_count), offset_of!(DeviceGroupSubmitInfo, p_signal_semaphore_device_indices));
    println!("DeviceGroupBindSparseInfo {} {} {} {} {} {}", size_of::<DeviceGroupBindSparseInfo>(), align_of::<DeviceGroupBindSparseInfo>(), offset_of!(DeviceGroupBindSparseInfo, s_type), offset_of!(DeviceGroupBindSparseInfo, p_next), offset_of!(DeviceGroupBindSparseInfo, resource_device_index), offset_of!(DeviceGroupBindSparseInfo, memory_device_index));
    println!("DeviceGroupPresentCapabilitiesKHR {} {} {} {} {} {}", size_of::<DeviceGroupPresentCapabilitiesKHR>(), align_of::<DeviceGroupPresentCapabilitiesKHR>(), offset_of!(DeviceGroupPresentCapabilitiesKHR, s_type), offset_of!(DeviceGroupPresentCapabilitiesKHR, p_next), offset_of!(DeviceGroupPresentCapabilitiesKHR, present_mask), offset_of!(DeviceGroupPresentCapabilitiesKHR, modes));
    println!("ImageSwapchainCreateInfoKHR {} {} {} {} {}", size_of::<ImageSwapchainCreateInfoKHR>(), align_of::<ImageSwapchainCreateInfoKHR>(), offset_of!(ImageSwapchainCreateInfoKHR, s_type), offset_of!(ImageSwapchainCreateInfoKHR, p_next), offset_of!(ImageSwapchainCreateInfoKHR, swapchain));
    println!("BindImageMemorySwapchainInfoKHR {} {} {} {} {} {}", size_of::<BindImageMemorySwapchainInfoKHR>(), align_of::<BindImageMemorySwapchainInfoKHR>(), offset_of!(BindImageMemorySwapchainInfoKHR, s_type), offset_of!(BindImageMemorySwapchainInfoKHR, p_next), offset_of!(BindImageMemorySwapchainInfoKHR, swapchain), offset_of!(BindImageMemorySwapchainInfoKHR, image_index));
    println!("AcquireNextImageInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<AcquireNextImageInfoKHR>(), align_of::<AcquireNextImageInfoKHR>(), offset_of!(AcquireNextImageInfoKHR, s_type), offset_of!(AcquireNextImageInfoKHR, p_next), offset_of!(AcquireNextImageInfoKHR, swapchain), offset_of!(AcquireNextImageInfoKHR, timeout), offset_of!(AcquireNextImageInfoKHR, semaphore), offset_of!(AcquireNextImageInfoKHR, fence), offset_of!(AcquireNextImageInfoKHR, device_mask));
    println!("DeviceGroupPresentInfoKHR {} {} {} {} {} {} {}", size_of::<DeviceGroupPresentInfoKHR>(), align_of::<DeviceGroupPresentInfoKHR>(), offset_of!(DeviceGroupPresentInfoKHR, s_type), offset_of!(DeviceGroupPresentInfoKHR, p_next), offset_of!(DeviceGroupPresentInfoKHR, swapchain_count), offset_of!(DeviceGroupPresentInfoKHR, p_device_masks), offset_of!(DeviceGroupPresentInfoKHR, mode));
    println!("DeviceGroupDeviceCreateInfo {} {} {} {} {} {}", size_of::<DeviceGroupDeviceCreateInfo>(), align_of::<DeviceGroupDeviceCreateInfo>(), offset_of!(DeviceGroupDeviceCreateInfo, s_type), offset_of!(DeviceGroupDeviceCreateInfo, p_next), offset_of!(DeviceGroupDeviceCreateInfo, physical_device_count), offset_of!(DeviceGroupDeviceCreateInfo, p_physical_devices));
    println!("DeviceGroupSwapchainCreateInfoKHR {} {} {} {} {}", size_of::<DeviceGroupSwapchainCreateInfoKHR>(), align_of::<DeviceGroupSwapchainCreateInfoKHR>(), offset_of!(DeviceGroupSwapchainCreateInfoKHR, s_type), offset_of!(DeviceGroupSwapchainCreateInfoKHR, p_next), offset_of!(DeviceGroupSwapchainCreateInfoKHR, modes));
    println!("DescriptorUpdateTemplateEntry {} {} {} {} {} {} {} {}", size_of::<DescriptorUpdateTemplateEntry>(), align_of::<DescriptorUpdateTemplateEntry>(), offset_of!(DescriptorUpdateTemplateEntry, dst_binding), offset_of!(DescriptorUpdateTemplateEntry, dst_array_element), offset_of!(DescriptorUpdateTemplateEntry, descriptor_count), offset_of!(DescriptorUpdateTemplateEntry, descriptor_type), offset_of!(DescriptorUpdateTemplateEntry, offset), offset_of!(DescriptorUpdateTemplateEntry, stride));
    println!("DescriptorUpdateTemplateCreateInfo {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorUpdateTemplateCreateInfo>(), align_of::<DescriptorUpdateTemplateCreateInfo>(), offset_of!(DescriptorUpdateTemplateCreateInfo, s_type), offset_of!(DescriptorUpdateTemplateCreateInfo, p_next), offset_of!(DescriptorUpdateTemplateCreateInfo, flags), offset_of!(DescriptorUpdateTemplateCreateInfo, descriptor_update_entry_count), offset_of!(DescriptorUpdateTemplateCreateInfo, p_descriptor_update_entries), offset_of!(DescriptorUpdateTemplateCreateInfo, template_type), offset_of!(DescriptorUpdateTemplateCreateInfo, descriptor_set_layout), offset_of!(DescriptorUpdateTemplateCreateInfo, pipeline_bind_point), offset_of!(DescriptorUpdateTemplateCreateInfo, pipeline_layout), offset_of!(DescriptorUpdateTemplateCreateInfo, set));
    println!("XYColorEXT {} {} {} {}", size_of::<XYColorEXT>(), align_of::<XYColorEXT>(), offset_of!(XYColorEXT, x), offset_of!(XYColorEXT, y));
    println!("PhysicalDevicePresentIdFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePresentIdFeaturesKHR>(), align_of::<PhysicalDevicePresentIdFeaturesKHR>(), offset_of!(PhysicalDevicePresentIdFeaturesKHR, s_type), offset_of!(PhysicalDevicePresentIdFeaturesKHR, p_next), offset_of!(PhysicalDevicePresentIdFeaturesKHR, present_id));
    println!("PresentIdKHR {} {} {} {} {} {}", size_of::<PresentIdKHR>(), align_of::<PresentIdKHR>(), offset_of!(PresentIdKHR, s_type), offset_of!(PresentIdKHR, p_next), offset_of!(PresentIdKHR, swapchain_count), offset_of!(PresentIdKHR, p_present_ids));
    println!("PhysicalDevicePresentId2FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePresentId2FeaturesKHR>(), align_of::<PhysicalDevicePresentId2FeaturesKHR>(), offset_of!(PhysicalDevicePresentId2FeaturesKHR, s_type), offset_of!(PhysicalDevicePresentId2FeaturesKHR, p_next), offset_of!(PhysicalDevicePresentId2FeaturesKHR, present_id2));
    println!("PresentId2KHR {} {} {} {} {} {}", size_of::<PresentId2KHR>(), align_of::<PresentId2KHR>(), offset_of!(PresentId2KHR, s_type), offset_of!(PresentId2KHR, p_next), offset_of!(PresentId2KHR, swapchain_count), offset_of!(PresentId2KHR, p_present_ids));
    println!("PresentWait2InfoKHR {} {} {} {} {} {}", size_of::<PresentWait2InfoKHR>(), align_of::<PresentWait2InfoKHR>(), offset_of!(PresentWait2InfoKHR, s_type), offset_of!(PresentWait2InfoKHR, p_next), offset_of!(PresentWait2InfoKHR, present_id), offset_of!(PresentWait2InfoKHR, timeout));
    println!("PhysicalDevicePresentWaitFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePresentWaitFeaturesKHR>(), align_of::<PhysicalDevicePresentWaitFeaturesKHR>(), offset_of!(PhysicalDevicePresentWaitFeaturesKHR, s_type), offset_of!(PhysicalDevicePresentWaitFeaturesKHR, p_next), offset_of!(PhysicalDevicePresentWaitFeaturesKHR, present_wait));
    println!("PhysicalDevicePresentWait2FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePresentWait2FeaturesKHR>(), align_of::<PhysicalDevicePresentWait2FeaturesKHR>(), offset_of!(PhysicalDevicePresentWait2FeaturesKHR, s_type), offset_of!(PhysicalDevicePresentWait2FeaturesKHR, p_next), offset_of!(PhysicalDevicePresentWait2FeaturesKHR, present_wait2));
    println!("PhysicalDevicePresentTimingFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDevicePresentTimingFeaturesEXT>(), align_of::<PhysicalDevicePresentTimingFeaturesEXT>(), offset_of!(PhysicalDevicePresentTimingFeaturesEXT, s_type), offset_of!(PhysicalDevicePresentTimingFeaturesEXT, p_next), offset_of!(PhysicalDevicePresentTimingFeaturesEXT, present_timing), offset_of!(PhysicalDevicePresentTimingFeaturesEXT, present_at_absolute_time), offset_of!(PhysicalDevicePresentTimingFeaturesEXT, present_at_relative_time));
    println!("PresentTimingSurfaceCapabilitiesEXT {} {} {} {} {} {} {} {}", size_of::<PresentTimingSurfaceCapabilitiesEXT>(), align_of::<PresentTimingSurfaceCapabilitiesEXT>(), offset_of!(PresentTimingSurfaceCapabilitiesEXT, s_type), offset_of!(PresentTimingSurfaceCapabilitiesEXT, p_next), offset_of!(PresentTimingSurfaceCapabilitiesEXT, present_timing_supported), offset_of!(PresentTimingSurfaceCapabilitiesEXT, present_at_absolute_time_supported), offset_of!(PresentTimingSurfaceCapabilitiesEXT, present_at_relative_time_supported), offset_of!(PresentTimingSurfaceCapabilitiesEXT, present_stage_queries));
    println!("SwapchainTimingPropertiesEXT {} {} {} {} {} {}", size_of::<SwapchainTimingPropertiesEXT>(), align_of::<SwapchainTimingPropertiesEXT>(), offset_of!(SwapchainTimingPropertiesEXT, s_type), offset_of!(SwapchainTimingPropertiesEXT, p_next), offset_of!(SwapchainTimingPropertiesEXT, refresh_duration), offset_of!(SwapchainTimingPropertiesEXT, refresh_interval));
    println!("SwapchainTimeDomainPropertiesEXT {} {} {} {} {} {} {}", size_of::<SwapchainTimeDomainPropertiesEXT>(), align_of::<SwapchainTimeDomainPropertiesEXT>(), offset_of!(SwapchainTimeDomainPropertiesEXT, s_type), offset_of!(SwapchainTimeDomainPropertiesEXT, p_next), offset_of!(SwapchainTimeDomainPropertiesEXT, time_domain_count), offset_of!(SwapchainTimeDomainPropertiesEXT, p_time_domains), offset_of!(SwapchainTimeDomainPropertiesEXT, p_time_domain_ids));
    println!("PresentStageTimeEXT {} {} {} {}", size_of::<PresentStageTimeEXT>(), align_of::<PresentStageTimeEXT>(), offset_of!(PresentStageTimeEXT, stage), offset_of!(PresentStageTimeEXT, time));
    println!("PastPresentationTimingInfoEXT {} {} {} {} {} {}", size_of::<PastPresentationTimingInfoEXT>(), align_of::<PastPresentationTimingInfoEXT>(), offset_of!(PastPresentationTimingInfoEXT, s_type), offset_of!(PastPresentationTimingInfoEXT, p_next), offset_of!(PastPresentationTimingInfoEXT, flags), offset_of!(PastPresentationTimingInfoEXT, swapchain));
    println!("PastPresentationTimingPropertiesEXT {} {} {} {} {} {} {} {}", size_of::<PastPresentationTimingPropertiesEXT>(), align_of::<PastPresentationTimingPropertiesEXT>(), offset_of!(PastPresentationTimingPropertiesEXT, s_type), offset_of!(PastPresentationTimingPropertiesEXT, p_next), offset_of!(PastPresentationTimingPropertiesEXT, timing_properties_counter), offset_of!(PastPresentationTimingPropertiesEXT, time_domains_counter), offset_of!(PastPresentationTimingPropertiesEXT, presentation_timing_count), offset_of!(PastPresentationTimingPropertiesEXT, p_presentation_timings));
    println!("PastPresentationTimingEXT {} {} {} {} {} {} {} {} {} {} {}", size_of::<PastPresentationTimingEXT>(), align_of::<PastPresentationTimingEXT>(), offset_of!(PastPresentationTimingEXT, s_type), offset_of!(PastPresentationTimingEXT, p_next), offset_of!(PastPresentationTimingEXT, present_id), offset_of!(PastPresentationTimingEXT, target_time), offset_of!(PastPresentationTimingEXT, present_stage_count), offset_of!(PastPresentationTimingEXT, p_present_stages), offset_of!(PastPresentationTimingEXT, time_domain), offset_of!(PastPresentationTimingEXT, time_domain_id), offset_of!(PastPresentationTimingEXT, report_complete));
    println!("PresentTimingsInfoEXT {} {} {} {} {} {}", size_of::<PresentTimingsInfoEXT>(), align_of::<PresentTimingsInfoEXT>(), offset_of!(PresentTimingsInfoEXT, s_type), offset_of!(PresentTimingsInfoEXT, p_next), offset_of!(PresentTimingsInfoEXT, swapchain_count), offset_of!(PresentTimingsInfoEXT, p_timing_infos));
    println!("PresentTimingInfoEXT {} {} {} {} {} {} {} {} {}", size_of::<PresentTimingInfoEXT>(), align_of::<PresentTimingInfoEXT>(), offset_of!(PresentTimingInfoEXT, s_type), offset_of!(PresentTimingInfoEXT, p_next), offset_of!(PresentTimingInfoEXT, flags), offset_of!(PresentTimingInfoEXT, target_time), offset_of!(PresentTimingInfoEXT, time_domain_id), offset_of!(PresentTimingInfoEXT, present_stage_queries), offset_of!(PresentTimingInfoEXT, target_time_domain_present_stage));
    println!("SwapchainCalibratedTimestampInfoEXT {} {} {} {} {} {} {}", size_of::<SwapchainCalibratedTimestampInfoEXT>(), align_of::<SwapchainCalibratedTimestampInfoEXT>(), offset_of!(SwapchainCalibratedTimestampInfoEXT, s_type), offset_of!(SwapchainCalibratedTimestampInfoEXT, p_next), offset_of!(SwapchainCalibratedTimestampInfoEXT, swapchain), offset_of!(SwapchainCalibratedTimestampInfoEXT, present_stage), offset_of!(SwapchainCalibratedTimestampInfoEXT, time_domain_id));
    println!("HdrMetadataEXT {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<HdrMetadataEXT>(), align_of::<HdrMetadataEXT>(), offset_of!(HdrMetadataEXT, s_type), offset_of!(HdrMetadataEXT, p_next), offset_of!(HdrMetadataEXT, display_primary_red), offset_of!(HdrMetadataEXT, display_primary_green), offset_of!(HdrMetadataEXT, display_primary_blue), offset_of!(HdrMetadataEXT, white_point), offset_of!(HdrMetadataEXT, max_luminance), offset_of!(HdrMetadataEXT, min_luminance), offset_of!(HdrMetadataEXT, max_content_light_level), offset_of!(HdrMetadataEXT, max_frame_average_light_level));
    println!("HdrVividDynamicMetadataHUAWEI {} {} {} {} {} {}", size_of::<HdrVividDynamicMetadataHUAWEI>(), align_of::<HdrVividDynamicMetadataHUAWEI>(), offset_of!(HdrVividDynamicMetadataHUAWEI, s_type), offset_of!(HdrVividDynamicMetadataHUAWEI, p_next), offset_of!(HdrVividDynamicMetadataHUAWEI, dynamic_metadata_size), offset_of!(HdrVividDynamicMetadataHUAWEI, p_dynamic_metadata));
    println!("DisplayNativeHdrSurfaceCapabilitiesAMD {} {} {} {} {}", size_of::<DisplayNativeHdrSurfaceCapabilitiesAMD>(), align_of::<DisplayNativeHdrSurfaceCapabilitiesAMD>(), offset_of!(DisplayNativeHdrSurfaceCapabilitiesAMD, s_type), offset_of!(DisplayNativeHdrSurfaceCapabilitiesAMD, p_next), offset_of!(DisplayNativeHdrSurfaceCapabilitiesAMD, local_dimming_support));
    println!("SwapchainDisplayNativeHdrCreateInfoAMD {} {} {} {} {}", size_of::<SwapchainDisplayNativeHdrCreateInfoAMD>(), align_of::<SwapchainDisplayNativeHdrCreateInfoAMD>(), offset_of!(SwapchainDisplayNativeHdrCreateInfoAMD, s_type), offset_of!(SwapchainDisplayNativeHdrCreateInfoAMD, p_next), offset_of!(SwapchainDisplayNativeHdrCreateInfoAMD, local_dimming_enable));
    println!("RefreshCycleDurationGOOGLE {} {} {}", size_of::<RefreshCycleDurationGOOGLE>(), align_of::<RefreshCycleDurationGOOGLE>(), offset_of!(RefreshCycleDurationGOOGLE, refresh_duration));
    println!("PastPresentationTimingGOOGLE {} {} {} {} {} {} {}", size_of::<PastPresentationTimingGOOGLE>(), align_of::<PastPresentationTimingGOOGLE>(), offset_of!(PastPresentationTimingGOOGLE, present_id), offset_of!(PastPresentationTimingGOOGLE, desired_present_time), offset_of!(PastPresentationTimingGOOGLE, actual_present_time), offset_of!(PastPresentationTimingGOOGLE, earliest_present_time), offset_of!(PastPresentationTimingGOOGLE, present_margin));
    println!("PresentTimesInfoGOOGLE {} {} {} {} {} {}", size_of::<PresentTimesInfoGOOGLE>(), align_of::<PresentTimesInfoGOOGLE>(), offset_of!(PresentTimesInfoGOOGLE, s_type), offset_of!(PresentTimesInfoGOOGLE, p_next), offset_of!(PresentTimesInfoGOOGLE, swapchain_count), offset_of!(PresentTimesInfoGOOGLE, p_times));
    println!("PresentTimeGOOGLE {} {} {} {}", size_of::<PresentTimeGOOGLE>(), align_of::<PresentTimeGOOGLE>(), offset_of!(PresentTimeGOOGLE, present_id), offset_of!(PresentTimeGOOGLE, desired_present_time));
    println!("ViewportWScalingNV {} {} {} {}", size_of::<ViewportWScalingNV>(), align_of::<ViewportWScalingNV>(), offset_of!(ViewportWScalingNV, xcoeff), offset_of!(ViewportWScalingNV, ycoeff));
    println!("PipelineViewportWScalingStateCreateInfoNV {} {} {} {} {} {} {}", size_of::<PipelineViewportWScalingStateCreateInfoNV>(), align_of::<PipelineViewportWScalingStateCreateInfoNV>(), offset_of!(PipelineViewportWScalingStateCreateInfoNV, s_type), offset_of!(PipelineViewportWScalingStateCreateInfoNV, p_next), offset_of!(PipelineViewportWScalingStateCreateInfoNV, viewport_w_scaling_enable), offset_of!(PipelineViewportWScalingStateCreateInfoNV, viewport_count), offset_of!(PipelineViewportWScalingStateCreateInfoNV, p_viewport_w_scalings));
    println!("ViewportSwizzleNV {} {} {} {} {} {}", size_of::<ViewportSwizzleNV>(), align_of::<ViewportSwizzleNV>(), offset_of!(ViewportSwizzleNV, x), offset_of!(ViewportSwizzleNV, y), offset_of!(ViewportSwizzleNV, z), offset_of!(ViewportSwizzleNV, w));
    println!("PipelineViewportSwizzleStateCreateInfoNV {} {} {} {} {} {} {}", size_of::<PipelineViewportSwizzleStateCreateInfoNV>(), align_of::<PipelineViewportSwizzleStateCreateInfoNV>(), offset_of!(PipelineViewportSwizzleStateCreateInfoNV, s_type), offset_of!(PipelineViewportSwizzleStateCreateInfoNV, p_next), offset_of!(PipelineViewportSwizzleStateCreateInfoNV, flags), offset_of!(PipelineViewportSwizzleStateCreateInfoNV, viewport_count), offset_of!(PipelineViewportSwizzleStateCreateInfoNV, p_viewport_swizzles));
    println!("PhysicalDeviceDiscardRectanglePropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDiscardRectanglePropertiesEXT>(), align_of::<PhysicalDeviceDiscardRectanglePropertiesEXT>(), offset_of!(PhysicalDeviceDiscardRectanglePropertiesEXT, s_type), offset_of!(PhysicalDeviceDiscardRectanglePropertiesEXT, p_next), offset_of!(PhysicalDeviceDiscardRectanglePropertiesEXT, max_discard_rectangles));
    println!("PipelineDiscardRectangleStateCreateInfoEXT {} {} {} {} {} {} {} {}", size_of::<PipelineDiscardRectangleStateCreateInfoEXT>(), align_of::<PipelineDiscardRectangleStateCreateInfoEXT>(), offset_of!(PipelineDiscardRectangleStateCreateInfoEXT, s_type), offset_of!(PipelineDiscardRectangleStateCreateInfoEXT, p_next), offset_of!(PipelineDiscardRectangleStateCreateInfoEXT, flags), offset_of!(PipelineDiscardRectangleStateCreateInfoEXT, discard_rectangle_mode), offset_of!(PipelineDiscardRectangleStateCreateInfoEXT, discard_rectangle_count), offset_of!(PipelineDiscardRectangleStateCreateInfoEXT, p_discard_rectangles));
    println!("PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {} {} {} {} {}", size_of::<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>(), align_of::<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>(), offset_of!(PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, s_type), offset_of!(PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, p_next), offset_of!(PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, per_view_position_all_components));
    println!("InputAttachmentAspectReference {} {} {} {} {}", size_of::<InputAttachmentAspectReference>(), align_of::<InputAttachmentAspectReference>(), offset_of!(InputAttachmentAspectReference, subpass), offset_of!(InputAttachmentAspectReference, input_attachment_index), offset_of!(InputAttachmentAspectReference, aspect_mask));
    println!("RenderPassInputAttachmentAspectCreateInfo {} {} {} {} {} {}", size_of::<RenderPassInputAttachmentAspectCreateInfo>(), align_of::<RenderPassInputAttachmentAspectCreateInfo>(), offset_of!(RenderPassInputAttachmentAspectCreateInfo, s_type), offset_of!(RenderPassInputAttachmentAspectCreateInfo, p_next), offset_of!(RenderPassInputAttachmentAspectCreateInfo, aspect_reference_count), offset_of!(RenderPassInputAttachmentAspectCreateInfo, p_aspect_references));
    println!("PhysicalDeviceSurfaceInfo2KHR {} {} {} {} {}", size_of::<PhysicalDeviceSurfaceInfo2KHR>(), align_of::<PhysicalDeviceSurfaceInfo2KHR>(), offset_of!(PhysicalDeviceSurfaceInfo2KHR, s_type), offset_of!(PhysicalDeviceSurfaceInfo2KHR, p_next), offset_of!(PhysicalDeviceSurfaceInfo2KHR, surface));
    println!("SurfaceCapabilities2KHR {} {} {} {} {}", size_of::<SurfaceCapabilities2KHR>(), align_of::<SurfaceCapabilities2KHR>(), offset_of!(SurfaceCapabilities2KHR, s_type), offset_of!(SurfaceCapabilities2KHR, p_next), offset_of!(SurfaceCapabilities2KHR, surface_capabilities));
    println!("SurfaceFormat2KHR {} {} {} {} {}", size_of::<SurfaceFormat2KHR>(), align_of::<SurfaceFormat2KHR>(), offset_of!(SurfaceFormat2KHR, s_type), offset_of!(SurfaceFormat2KHR, p_next), offset_of!(SurfaceFormat2KHR, surface_format));
    println!("DisplayProperties2KHR {} {} {} {} {}", size_of::<DisplayProperties2KHR>(), align_of::<DisplayProperties2KHR>(), offset_of!(DisplayProperties2KHR, s_type), offset_of!(DisplayProperties2KHR, p_next), offset_of!(DisplayProperties2KHR, display_properties));
    println!("DisplayPlaneProperties2KHR {} {} {} {} {}", size_of::<DisplayPlaneProperties2KHR>(), align_of::<DisplayPlaneProperties2KHR>(), offset_of!(DisplayPlaneProperties2KHR, s_type), offset_of!(DisplayPlaneProperties2KHR, p_next), offset_of!(DisplayPlaneProperties2KHR, display_plane_properties));
    println!("DisplayModeProperties2KHR {} {} {} {} {}", size_of::<DisplayModeProperties2KHR>(), align_of::<DisplayModeProperties2KHR>(), offset_of!(DisplayModeProperties2KHR, s_type), offset_of!(DisplayModeProperties2KHR, p_next), offset_of!(DisplayModeProperties2KHR, display_mode_properties));
    println!("DisplayModeStereoPropertiesNV {} {} {} {} {}", size_of::<DisplayModeStereoPropertiesNV>(), align_of::<DisplayModeStereoPropertiesNV>(), offset_of!(DisplayModeStereoPropertiesNV, s_type), offset_of!(DisplayModeStereoPropertiesNV, p_next), offset_of!(DisplayModeStereoPropertiesNV, hdmi3_d_supported));
    println!("DisplayPlaneInfo2KHR {} {} {} {} {} {}", size_of::<DisplayPlaneInfo2KHR>(), align_of::<DisplayPlaneInfo2KHR>(), offset_of!(DisplayPlaneInfo2KHR, s_type), offset_of!(DisplayPlaneInfo2KHR, p_next), offset_of!(DisplayPlaneInfo2KHR, mode), offset_of!(DisplayPlaneInfo2KHR, plane_index));
    println!("DisplayPlaneCapabilities2KHR {} {} {} {} {}", size_of::<DisplayPlaneCapabilities2KHR>(), align_of::<DisplayPlaneCapabilities2KHR>(), offset_of!(DisplayPlaneCapabilities2KHR, s_type), offset_of!(DisplayPlaneCapabilities2KHR, p_next), offset_of!(DisplayPlaneCapabilities2KHR, capabilities));
    println!("SharedPresentSurfaceCapabilitiesKHR {} {} {} {} {}", size_of::<SharedPresentSurfaceCapabilitiesKHR>(), align_of::<SharedPresentSurfaceCapabilitiesKHR>(), offset_of!(SharedPresentSurfaceCapabilitiesKHR, s_type), offset_of!(SharedPresentSurfaceCapabilitiesKHR, p_next), offset_of!(SharedPresentSurfaceCapabilitiesKHR, shared_present_supported_usage_flags));
    println!("PhysicalDevice16BitStorageFeatures {} {} {} {} {} {} {} {}", size_of::<PhysicalDevice16BitStorageFeatures>(), align_of::<PhysicalDevice16BitStorageFeatures>(), offset_of!(PhysicalDevice16BitStorageFeatures, s_type), offset_of!(PhysicalDevice16BitStorageFeatures, p_next), offset_of!(PhysicalDevice16BitStorageFeatures, storage_buffer16_bit_access), offset_of!(PhysicalDevice16BitStorageFeatures, uniform_and_storage_buffer16_bit_access), offset_of!(PhysicalDevice16BitStorageFeatures, storage_push_constant16), offset_of!(PhysicalDevice16BitStorageFeatures, storage_input_output16));
    println!("PhysicalDeviceSubgroupProperties {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceSubgroupProperties>(), align_of::<PhysicalDeviceSubgroupProperties>(), offset_of!(PhysicalDeviceSubgroupProperties, s_type), offset_of!(PhysicalDeviceSubgroupProperties, p_next), offset_of!(PhysicalDeviceSubgroupProperties, subgroup_size), offset_of!(PhysicalDeviceSubgroupProperties, supported_stages), offset_of!(PhysicalDeviceSubgroupProperties, supported_operations), offset_of!(PhysicalDeviceSubgroupProperties, quad_operations_in_all_stages));
    println!("PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} {} {} {} {}", size_of::<PhysicalDeviceShaderSubgroupExtendedTypesFeatures>(), align_of::<PhysicalDeviceShaderSubgroupExtendedTypesFeatures>(), offset_of!(PhysicalDeviceShaderSubgroupExtendedTypesFeatures, s_type), offset_of!(PhysicalDeviceShaderSubgroupExtendedTypesFeatures, p_next), offset_of!(PhysicalDeviceShaderSubgroupExtendedTypesFeatures, shader_subgroup_extended_types));
    println!("BufferMemoryRequirementsInfo2 {} {} {} {} {}", size_of::<BufferMemoryRequirementsInfo2>(), align_of::<BufferMemoryRequirementsInfo2>(), offset_of!(BufferMemoryRequirementsInfo2, s_type), offset_of!(BufferMemoryRequirementsInfo2, p_next), offset_of!(BufferMemoryRequirementsInfo2, buffer));
    println!("DeviceBufferMemoryRequirements {} {} {} {} {}", size_of::<DeviceBufferMemoryRequirements>(), align_of::<DeviceBufferMemoryRequirements>(), offset_of!(DeviceBufferMemoryRequirements, s_type), offset_of!(DeviceBufferMemoryRequirements, p_next), offset_of!(DeviceBufferMemoryRequirements, p_create_info));
    println!("ImageMemoryRequirementsInfo2 {} {} {} {} {}", size_of::<ImageMemoryRequirementsInfo2>(), align_of::<ImageMemoryRequirementsInfo2>(), offset_of!(ImageMemoryRequirementsInfo2, s_type), offset_of!(ImageMemoryRequirementsInfo2, p_next), offset_of!(ImageMemoryRequirementsInfo2, image));
    println!("ImageSparseMemoryRequirementsInfo2 {} {} {} {} {}", size_of::<ImageSparseMemoryRequirementsInfo2>(), align_of::<ImageSparseMemoryRequirementsInfo2>(), offset_of!(ImageSparseMemoryRequirementsInfo2, s_type), offset_of!(ImageSparseMemoryRequirementsInfo2, p_next), offset_of!(ImageSparseMemoryRequirementsInfo2, image));
    println!("DeviceImageMemoryRequirements {} {} {} {} {} {}", size_of::<DeviceImageMemoryRequirements>(), align_of::<DeviceImageMemoryRequirements>(), offset_of!(DeviceImageMemoryRequirements, s_type), offset_of!(DeviceImageMemoryRequirements, p_next), offset_of!(DeviceImageMemoryRequirements, p_create_info), offset_of!(DeviceImageMemoryRequirements, plane_aspect));
    println!("MemoryRequirements2 {} {} {} {} {}", size_of::<MemoryRequirements2>(), align_of::<MemoryRequirements2>(), offset_of!(MemoryRequirements2, s_type), offset_of!(MemoryRequirements2, p_next), offset_of!(MemoryRequirements2, memory_requirements));
    println!("SparseImageMemoryRequirements2 {} {} {} {} {}", size_of::<SparseImageMemoryRequirements2>(), align_of::<SparseImageMemoryRequirements2>(), offset_of!(SparseImageMemoryRequirements2, s_type), offset_of!(SparseImageMemoryRequirements2, p_next), offset_of!(SparseImageMemoryRequirements2, memory_requirements));
    println!("PhysicalDevicePointClippingProperties {} {} {} {} {}", size_of::<PhysicalDevicePointClippingProperties>(), align_of::<PhysicalDevicePointClippingProperties>(), offset_of!(PhysicalDevicePointClippingProperties, s_type), offset_of!(PhysicalDevicePointClippingProperties, p_next), offset_of!(PhysicalDevicePointClippingProperties, point_clipping_behavior));
    println!("MemoryDedicatedRequirements {} {} {} {} {} {}", size_of::<MemoryDedicatedRequirements>(), align_of::<MemoryDedicatedRequirements>(), offset_of!(MemoryDedicatedRequirements, s_type), offset_of!(MemoryDedicatedRequirements, p_next), offset_of!(MemoryDedicatedRequirements, prefers_dedicated_allocation), offset_of!(MemoryDedicatedRequirements, requires_dedicated_allocation));
    println!("MemoryDedicatedAllocateInfo {} {} {} {} {} {}", size_of::<MemoryDedicatedAllocateInfo>(), align_of::<MemoryDedicatedAllocateInfo>(), offset_of!(MemoryDedicatedAllocateInfo, s_type), offset_of!(MemoryDedicatedAllocateInfo, p_next), offset_of!(MemoryDedicatedAllocateInfo, image), offset_of!(MemoryDedicatedAllocateInfo, buffer));
    println!("ImageViewUsageCreateInfo {} {} {} {} {}", size_of::<ImageViewUsageCreateInfo>(), align_of::<ImageViewUsageCreateInfo>(), offset_of!(ImageViewUsageCreateInfo, s_type), offset_of!(ImageViewUsageCreateInfo, p_next), offset_of!(ImageViewUsageCreateInfo, usage));
    println!("ImageViewSlicedCreateInfoEXT {} {} {} {} {} {}", size_of::<ImageViewSlicedCreateInfoEXT>(), align_of::<ImageViewSlicedCreateInfoEXT>(), offset_of!(ImageViewSlicedCreateInfoEXT, s_type), offset_of!(ImageViewSlicedCreateInfoEXT, p_next), offset_of!(ImageViewSlicedCreateInfoEXT, slice_offset), offset_of!(ImageViewSlicedCreateInfoEXT, slice_count));
    println!("PipelineTessellationDomainOriginStateCreateInfo {} {} {} {} {}", size_of::<PipelineTessellationDomainOriginStateCreateInfo>(), align_of::<PipelineTessellationDomainOriginStateCreateInfo>(), offset_of!(PipelineTessellationDomainOriginStateCreateInfo, s_type), offset_of!(PipelineTessellationDomainOriginStateCreateInfo, p_next), offset_of!(PipelineTessellationDomainOriginStateCreateInfo, domain_origin));
    println!("SamplerYcbcrConversionInfo {} {} {} {} {}", size_of::<SamplerYcbcrConversionInfo>(), align_of::<SamplerYcbcrConversionInfo>(), offset_of!(SamplerYcbcrConversionInfo, s_type), offset_of!(SamplerYcbcrConversionInfo, p_next), offset_of!(SamplerYcbcrConversionInfo, conversion));
    println!("SamplerYcbcrConversionCreateInfo {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SamplerYcbcrConversionCreateInfo>(), align_of::<SamplerYcbcrConversionCreateInfo>(), offset_of!(SamplerYcbcrConversionCreateInfo, s_type), offset_of!(SamplerYcbcrConversionCreateInfo, p_next), offset_of!(SamplerYcbcrConversionCreateInfo, format), offset_of!(SamplerYcbcrConversionCreateInfo, ycbcr_model), offset_of!(SamplerYcbcrConversionCreateInfo, ycbcr_range), offset_of!(SamplerYcbcrConversionCreateInfo, components), offset_of!(SamplerYcbcrConversionCreateInfo, x_chroma_offset), offset_of!(SamplerYcbcrConversionCreateInfo, y_chroma_offset), offset_of!(SamplerYcbcrConversionCreateInfo, chroma_filter), offset_of!(SamplerYcbcrConversionCreateInfo, force_explicit_reconstruction));
    println!("BindImagePlaneMemoryInfo {} {} {} {} {}", size_of::<BindImagePlaneMemoryInfo>(), align_of::<BindImagePlaneMemoryInfo>(), offset_of!(BindImagePlaneMemoryInfo, s_type), offset_of!(BindImagePlaneMemoryInfo, p_next), offset_of!(BindImagePlaneMemoryInfo, plane_aspect));
    println!("ImagePlaneMemoryRequirementsInfo {} {} {} {} {}", size_of::<ImagePlaneMemoryRequirementsInfo>(), align_of::<ImagePlaneMemoryRequirementsInfo>(), offset_of!(ImagePlaneMemoryRequirementsInfo, s_type), offset_of!(ImagePlaneMemoryRequirementsInfo, p_next), offset_of!(ImagePlaneMemoryRequirementsInfo, plane_aspect));
    println!("PhysicalDeviceSamplerYcbcrConversionFeatures {} {} {} {} {}", size_of::<PhysicalDeviceSamplerYcbcrConversionFeatures>(), align_of::<PhysicalDeviceSamplerYcbcrConversionFeatures>(), offset_of!(PhysicalDeviceSamplerYcbcrConversionFeatures, s_type), offset_of!(PhysicalDeviceSamplerYcbcrConversionFeatures, p_next), offset_of!(PhysicalDeviceSamplerYcbcrConversionFeatures, sampler_ycbcr_conversion));
    println!("SamplerYcbcrConversionImageFormatProperties {} {} {} {} {}", size_of::<SamplerYcbcrConversionImageFormatProperties>(), align_of::<SamplerYcbcrConversionImageFormatProperties>(), offset_of!(SamplerYcbcrConversionImageFormatProperties, s_type), offset_of!(SamplerYcbcrConversionImageFormatProperties, p_next), offset_of!(SamplerYcbcrConversionImageFormatProperties, combined_image_sampler_descriptor_count));
    println!("TextureLODGatherFormatPropertiesAMD {} {} {} {} {}", size_of::<TextureLODGatherFormatPropertiesAMD>(), align_of::<TextureLODGatherFormatPropertiesAMD>(), offset_of!(TextureLODGatherFormatPropertiesAMD, s_type), offset_of!(TextureLODGatherFormatPropertiesAMD, p_next), offset_of!(TextureLODGatherFormatPropertiesAMD, supports_texture_gather_lod_bias_amd));
    println!("ConditionalRenderingBeginInfoEXT {} {} {} {} {} {} {}", size_of::<ConditionalRenderingBeginInfoEXT>(), align_of::<ConditionalRenderingBeginInfoEXT>(), offset_of!(ConditionalRenderingBeginInfoEXT, s_type), offset_of!(ConditionalRenderingBeginInfoEXT, p_next), offset_of!(ConditionalRenderingBeginInfoEXT, buffer), offset_of!(ConditionalRenderingBeginInfoEXT, offset), offset_of!(ConditionalRenderingBeginInfoEXT, flags));
    println!("ProtectedSubmitInfo {} {} {} {} {}", size_of::<ProtectedSubmitInfo>(), align_of::<ProtectedSubmitInfo>(), offset_of!(ProtectedSubmitInfo, s_type), offset_of!(ProtectedSubmitInfo, p_next), offset_of!(ProtectedSubmitInfo, protected_submit));
    println!("PhysicalDeviceProtectedMemoryFeatures {} {} {} {} {}", size_of::<PhysicalDeviceProtectedMemoryFeatures>(), align_of::<PhysicalDeviceProtectedMemoryFeatures>(), offset_of!(PhysicalDeviceProtectedMemoryFeatures, s_type), offset_of!(PhysicalDeviceProtectedMemoryFeatures, p_next), offset_of!(PhysicalDeviceProtectedMemoryFeatures, protected_memory));
    println!("PhysicalDeviceProtectedMemoryProperties {} {} {} {} {}", size_of::<PhysicalDeviceProtectedMemoryProperties>(), align_of::<PhysicalDeviceProtectedMemoryProperties>(), offset_of!(PhysicalDeviceProtectedMemoryProperties, s_type), offset_of!(PhysicalDeviceProtectedMemoryProperties, p_next), offset_of!(PhysicalDeviceProtectedMemoryProperties, protected_no_fault));
    println!("DeviceQueueInfo2 {} {} {} {} {} {} {}", size_of::<DeviceQueueInfo2>(), align_of::<DeviceQueueInfo2>(), offset_of!(DeviceQueueInfo2, s_type), offset_of!(DeviceQueueInfo2, p_next), offset_of!(DeviceQueueInfo2, flags), offset_of!(DeviceQueueInfo2, queue_family_index), offset_of!(DeviceQueueInfo2, queue_index));
    println!("PipelineCoverageToColorStateCreateInfoNV {} {} {} {} {} {} {}", size_of::<PipelineCoverageToColorStateCreateInfoNV>(), align_of::<PipelineCoverageToColorStateCreateInfoNV>(), offset_of!(PipelineCoverageToColorStateCreateInfoNV, s_type), offset_of!(PipelineCoverageToColorStateCreateInfoNV, p_next), offset_of!(PipelineCoverageToColorStateCreateInfoNV, flags), offset_of!(PipelineCoverageToColorStateCreateInfoNV, coverage_to_color_enable), offset_of!(PipelineCoverageToColorStateCreateInfoNV, coverage_to_color_location));
    println!("PhysicalDeviceSamplerFilterMinmaxProperties {} {} {} {} {} {}", size_of::<PhysicalDeviceSamplerFilterMinmaxProperties>(), align_of::<PhysicalDeviceSamplerFilterMinmaxProperties>(), offset_of!(PhysicalDeviceSamplerFilterMinmaxProperties, s_type), offset_of!(PhysicalDeviceSamplerFilterMinmaxProperties, p_next), offset_of!(PhysicalDeviceSamplerFilterMinmaxProperties, filter_minmax_single_component_formats), offset_of!(PhysicalDeviceSamplerFilterMinmaxProperties, filter_minmax_image_component_mapping));
    println!("SampleLocationEXT {} {} {} {}", size_of::<SampleLocationEXT>(), align_of::<SampleLocationEXT>(), offset_of!(SampleLocationEXT, x), offset_of!(SampleLocationEXT, y));
    println!("SampleLocationsInfoEXT {} {} {} {} {} {} {} {}", size_of::<SampleLocationsInfoEXT>(), align_of::<SampleLocationsInfoEXT>(), offset_of!(SampleLocationsInfoEXT, s_type), offset_of!(SampleLocationsInfoEXT, p_next), offset_of!(SampleLocationsInfoEXT, sample_locations_per_pixel), offset_of!(SampleLocationsInfoEXT, sample_location_grid_size), offset_of!(SampleLocationsInfoEXT, sample_locations_count), offset_of!(SampleLocationsInfoEXT, p_sample_locations));
    println!("AttachmentSampleLocationsEXT {} {} {} {}", size_of::<AttachmentSampleLocationsEXT>(), align_of::<AttachmentSampleLocationsEXT>(), offset_of!(AttachmentSampleLocationsEXT, attachment_index), offset_of!(AttachmentSampleLocationsEXT, sample_locations_info));
    println!("SubpassSampleLocationsEXT {} {} {} {}", size_of::<SubpassSampleLocationsEXT>(), align_of::<SubpassSampleLocationsEXT>(), offset_of!(SubpassSampleLocationsEXT, subpass_index), offset_of!(SubpassSampleLocationsEXT, sample_locations_info));
    println!("RenderPassSampleLocationsBeginInfoEXT {} {} {} {} {} {} {} {}", size_of::<RenderPassSampleLocationsBeginInfoEXT>(), align_of::<RenderPassSampleLocationsBeginInfoEXT>(), offset_of!(RenderPassSampleLocationsBeginInfoEXT, s_type), offset_of!(RenderPassSampleLocationsBeginInfoEXT, p_next), offset_of!(RenderPassSampleLocationsBeginInfoEXT, attachment_initial_sample_locations_count), offset_of!(RenderPassSampleLocationsBeginInfoEXT, p_attachment_initial_sample_locations), offset_of!(RenderPassSampleLocationsBeginInfoEXT, post_subpass_sample_locations_count), offset_of!(RenderPassSampleLocationsBeginInfoEXT, p_post_subpass_sample_locations));
    println!("PipelineSampleLocationsStateCreateInfoEXT {} {} {} {} {} {}", size_of::<PipelineSampleLocationsStateCreateInfoEXT>(), align_of::<PipelineSampleLocationsStateCreateInfoEXT>(), offset_of!(PipelineSampleLocationsStateCreateInfoEXT, s_type), offset_of!(PipelineSampleLocationsStateCreateInfoEXT, p_next), offset_of!(PipelineSampleLocationsStateCreateInfoEXT, sample_locations_enable), offset_of!(PipelineSampleLocationsStateCreateInfoEXT, sample_locations_info));
    println!("PhysicalDeviceSampleLocationsPropertiesEXT {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceSampleLocationsPropertiesEXT>(), align_of::<PhysicalDeviceSampleLocationsPropertiesEXT>(), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, s_type), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, p_next), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, sample_location_sample_counts), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, max_sample_location_grid_size), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, sample_location_coordinate_range), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, sample_location_sub_pixel_bits), offset_of!(PhysicalDeviceSampleLocationsPropertiesEXT, variable_sample_locations));
    println!("MultisamplePropertiesEXT {} {} {} {} {}", size_of::<MultisamplePropertiesEXT>(), align_of::<MultisamplePropertiesEXT>(), offset_of!(MultisamplePropertiesEXT, s_type), offset_of!(MultisamplePropertiesEXT, p_next), offset_of!(MultisamplePropertiesEXT, max_sample_location_grid_size));
    println!("SamplerReductionModeCreateInfo {} {} {} {} {}", size_of::<SamplerReductionModeCreateInfo>(), align_of::<SamplerReductionModeCreateInfo>(), offset_of!(SamplerReductionModeCreateInfo, s_type), offset_of!(SamplerReductionModeCreateInfo, p_next), offset_of!(SamplerReductionModeCreateInfo, reduction_mode));
    println!("PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>(), align_of::<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>(), offset_of!(PhysicalDeviceBlendOperationAdvancedFeaturesEXT, s_type), offset_of!(PhysicalDeviceBlendOperationAdvancedFeaturesEXT, p_next), offset_of!(PhysicalDeviceBlendOperationAdvancedFeaturesEXT, advanced_blend_coherent_operations));
    println!("PhysicalDeviceMultiDrawFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMultiDrawFeaturesEXT>(), align_of::<PhysicalDeviceMultiDrawFeaturesEXT>(), offset_of!(PhysicalDeviceMultiDrawFeaturesEXT, s_type), offset_of!(PhysicalDeviceMultiDrawFeaturesEXT, p_next), offset_of!(PhysicalDeviceMultiDrawFeaturesEXT, multi_draw));
    println!("PhysicalDeviceBlendOperationAdvancedPropertiesEXT {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>(), align_of::<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>(), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, s_type), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, p_next), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, advanced_blend_max_color_attachments), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, advanced_blend_independent_blend), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, advanced_blend_non_premultiplied_src_color), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, advanced_blend_non_premultiplied_dst_color), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, advanced_blend_correlated_overlap), offset_of!(PhysicalDeviceBlendOperationAdvancedPropertiesEXT, advanced_blend_all_operations));
    println!("PipelineColorBlendAdvancedStateCreateInfoEXT {} {} {} {} {} {} {}", size_of::<PipelineColorBlendAdvancedStateCreateInfoEXT>(), align_of::<PipelineColorBlendAdvancedStateCreateInfoEXT>(), offset_of!(PipelineColorBlendAdvancedStateCreateInfoEXT, s_type), offset_of!(PipelineColorBlendAdvancedStateCreateInfoEXT, p_next), offset_of!(PipelineColorBlendAdvancedStateCreateInfoEXT, src_premultiplied), offset_of!(PipelineColorBlendAdvancedStateCreateInfoEXT, dst_premultiplied), offset_of!(PipelineColorBlendAdvancedStateCreateInfoEXT, blend_overlap));
    println!("PhysicalDeviceInlineUniformBlockFeatures {} {} {} {} {} {}", size_of::<PhysicalDeviceInlineUniformBlockFeatures>(), align_of::<PhysicalDeviceInlineUniformBlockFeatures>(), offset_of!(PhysicalDeviceInlineUniformBlockFeatures, s_type), offset_of!(PhysicalDeviceInlineUniformBlockFeatures, p_next), offset_of!(PhysicalDeviceInlineUniformBlockFeatures, inline_uniform_block), offset_of!(PhysicalDeviceInlineUniformBlockFeatures, descriptor_binding_inline_uniform_block_update_after_bind));
    println!("PhysicalDeviceInlineUniformBlockProperties {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceInlineUniformBlockProperties>(), align_of::<PhysicalDeviceInlineUniformBlockProperties>(), offset_of!(PhysicalDeviceInlineUniformBlockProperties, s_type), offset_of!(PhysicalDeviceInlineUniformBlockProperties, p_next), offset_of!(PhysicalDeviceInlineUniformBlockProperties, max_inline_uniform_block_size), offset_of!(PhysicalDeviceInlineUniformBlockProperties, max_per_stage_descriptor_inline_uniform_blocks), offset_of!(PhysicalDeviceInlineUniformBlockProperties, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks), offset_of!(PhysicalDeviceInlineUniformBlockProperties, max_descriptor_set_inline_uniform_blocks), offset_of!(PhysicalDeviceInlineUniformBlockProperties, max_descriptor_set_update_after_bind_inline_uniform_blocks));
    println!("WriteDescriptorSetInlineUniformBlock {} {} {} {} {} {}", size_of::<WriteDescriptorSetInlineUniformBlock>(), align_of::<WriteDescriptorSetInlineUniformBlock>(), offset_of!(WriteDescriptorSetInlineUniformBlock, s_type), offset_of!(WriteDescriptorSetInlineUniformBlock, p_next), offset_of!(WriteDescriptorSetInlineUniformBlock, data_size), offset_of!(WriteDescriptorSetInlineUniformBlock, p_data));
    println!("DescriptorPoolInlineUniformBlockCreateInfo {} {} {} {} {}", size_of::<DescriptorPoolInlineUniformBlockCreateInfo>(), align_of::<DescriptorPoolInlineUniformBlockCreateInfo>(), offset_of!(DescriptorPoolInlineUniformBlockCreateInfo, s_type), offset_of!(DescriptorPoolInlineUniformBlockCreateInfo, p_next), offset_of!(DescriptorPoolInlineUniformBlockCreateInfo, max_inline_uniform_block_bindings));
    println!("PipelineCoverageModulationStateCreateInfoNV {} {} {} {} {} {} {} {} {}", size_of::<PipelineCoverageModulationStateCreateInfoNV>(), align_of::<PipelineCoverageModulationStateCreateInfoNV>(), offset_of!(PipelineCoverageModulationStateCreateInfoNV, s_type), offset_of!(PipelineCoverageModulationStateCreateInfoNV, p_next), offset_of!(PipelineCoverageModulationStateCreateInfoNV, flags), offset_of!(PipelineCoverageModulationStateCreateInfoNV, coverage_modulation_mode), offset_of!(PipelineCoverageModulationStateCreateInfoNV, coverage_modulation_table_enable), offset_of!(PipelineCoverageModulationStateCreateInfoNV, coverage_modulation_table_count), offset_of!(PipelineCoverageModulationStateCreateInfoNV, p_coverage_modulation_table));
    println!("ImageFormatListCreateInfo {} {} {} {} {} {}", size_of::<ImageFormatListCreateInfo>(), align_of::<ImageFormatListCreateInfo>(), offset_of!(ImageFormatListCreateInfo, s_type), offset_of!(ImageFormatListCreateInfo, p_next), offset_of!(ImageFormatListCreateInfo, view_format_count), offset_of!(ImageFormatListCreateInfo, p_view_formats));
    println!("ValidationCacheCreateInfoEXT {} {} {} {} {} {} {}", size_of::<ValidationCacheCreateInfoEXT>(), align_of::<ValidationCacheCreateInfoEXT>(), offset_of!(ValidationCacheCreateInfoEXT, s_type), offset_of!(ValidationCacheCreateInfoEXT, p_next), offset_of!(ValidationCacheCreateInfoEXT, flags), offset_of!(ValidationCacheCreateInfoEXT, initial_data_size), offset_of!(ValidationCacheCreateInfoEXT, p_initial_data));
    println!("ShaderModuleValidationCacheCreateInfoEXT {} {} {} {} {}", size_of::<ShaderModuleValidationCacheCreateInfoEXT>(), align_of::<ShaderModuleValidationCacheCreateInfoEXT>(), offset_of!(ShaderModuleValidationCacheCreateInfoEXT, s_type), offset_of!(ShaderModuleValidationCacheCreateInfoEXT, p_next), offset_of!(ShaderModuleValidationCacheCreateInfoEXT, validation_cache));
    println!("PhysicalDeviceMaintenance3Properties {} {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance3Properties>(), align_of::<PhysicalDeviceMaintenance3Properties>(), offset_of!(PhysicalDeviceMaintenance3Properties, s_type), offset_of!(PhysicalDeviceMaintenance3Properties, p_next), offset_of!(PhysicalDeviceMaintenance3Properties, max_per_set_descriptors), offset_of!(PhysicalDeviceMaintenance3Properties, max_memory_allocation_size));
    println!("PhysicalDeviceMaintenance4Features {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance4Features>(), align_of::<PhysicalDeviceMaintenance4Features>(), offset_of!(PhysicalDeviceMaintenance4Features, s_type), offset_of!(PhysicalDeviceMaintenance4Features, p_next), offset_of!(PhysicalDeviceMaintenance4Features, maintenance4));
    println!("PhysicalDeviceMaintenance4Properties {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance4Properties>(), align_of::<PhysicalDeviceMaintenance4Properties>(), offset_of!(PhysicalDeviceMaintenance4Properties, s_type), offset_of!(PhysicalDeviceMaintenance4Properties, p_next), offset_of!(PhysicalDeviceMaintenance4Properties, max_buffer_size));
    println!("PhysicalDeviceMaintenance5Features {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance5Features>(), align_of::<PhysicalDeviceMaintenance5Features>(), offset_of!(PhysicalDeviceMaintenance5Features, s_type), offset_of!(PhysicalDeviceMaintenance5Features, p_next), offset_of!(PhysicalDeviceMaintenance5Features, maintenance5));
    println!("PhysicalDeviceMaintenance5Properties {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance5Properties>(), align_of::<PhysicalDeviceMaintenance5Properties>(), offset_of!(PhysicalDeviceMaintenance5Properties, s_type), offset_of!(PhysicalDeviceMaintenance5Properties, p_next), offset_of!(PhysicalDeviceMaintenance5Properties, early_fragment_multisample_coverage_after_sample_counting), offset_of!(PhysicalDeviceMaintenance5Properties, early_fragment_sample_mask_test_before_sample_counting), offset_of!(PhysicalDeviceMaintenance5Properties, depth_stencil_swizzle_one_support), offset_of!(PhysicalDeviceMaintenance5Properties, polygon_mode_point_size), offset_of!(PhysicalDeviceMaintenance5Properties, non_strict_single_pixel_wide_lines_use_parallelogram), offset_of!(PhysicalDeviceMaintenance5Properties, non_strict_wide_lines_use_parallelogram));
    println!("PhysicalDeviceMaintenance6Features {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance6Features>(), align_of::<PhysicalDeviceMaintenance6Features>(), offset_of!(PhysicalDeviceMaintenance6Features, s_type), offset_of!(PhysicalDeviceMaintenance6Features, p_next), offset_of!(PhysicalDeviceMaintenance6Features, maintenance6));
    println!("PhysicalDeviceMaintenance6Properties {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance6Properties>(), align_of::<PhysicalDeviceMaintenance6Properties>(), offset_of!(PhysicalDeviceMaintenance6Properties, s_type), offset_of!(PhysicalDeviceMaintenance6Properties, p_next), offset_of!(PhysicalDeviceMaintenance6Properties, block_texel_view_compatible_multiple_layers), offset_of!(PhysicalDeviceMaintenance6Properties, max_combined_image_sampler_descriptor_count), offset_of!(PhysicalDeviceMaintenance6Properties, fragment_shading_rate_clamp_combiner_inputs));
    println!("PhysicalDeviceMaintenance7FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance7FeaturesKHR>(), align_of::<PhysicalDeviceMaintenance7FeaturesKHR>(), offset_of!(PhysicalDeviceMaintenance7FeaturesKHR, s_type), offset_of!(PhysicalDeviceMaintenance7FeaturesKHR, p_next), offset_of!(PhysicalDeviceMaintenance7FeaturesKHR, maintenance7));
    println!("PhysicalDeviceMaintenance7PropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance7PropertiesKHR>(), align_of::<PhysicalDeviceMaintenance7PropertiesKHR>(), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, s_type), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, p_next), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, robust_fragment_shading_rate_attachment_access), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, separate_depth_stencil_attachment_access), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, max_descriptor_set_total_uniform_buffers_dynamic), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, max_descriptor_set_total_storage_buffers_dynamic), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, max_descriptor_set_total_buffers_dynamic), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, max_descriptor_set_update_after_bind_total_storage_buffers_dynamic), offset_of!(PhysicalDeviceMaintenance7PropertiesKHR, max_descriptor_set_update_after_bind_total_buffers_dynamic));
    println!("PhysicalDeviceLayeredApiPropertiesListKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceLayeredApiPropertiesListKHR>(), align_of::<PhysicalDeviceLayeredApiPropertiesListKHR>(), offset_of!(PhysicalDeviceLayeredApiPropertiesListKHR, s_type), offset_of!(PhysicalDeviceLayeredApiPropertiesListKHR, p_next), offset_of!(PhysicalDeviceLayeredApiPropertiesListKHR, layered_api_count), offset_of!(PhysicalDeviceLayeredApiPropertiesListKHR, p_layered_apis));
    println!("PhysicalDeviceLayeredApiPropertiesKHR {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceLayeredApiPropertiesKHR>(), align_of::<PhysicalDeviceLayeredApiPropertiesKHR>(), offset_of!(PhysicalDeviceLayeredApiPropertiesKHR, s_type), offset_of!(PhysicalDeviceLayeredApiPropertiesKHR, p_next), offset_of!(PhysicalDeviceLayeredApiPropertiesKHR, vendor_id), offset_of!(PhysicalDeviceLayeredApiPropertiesKHR, device_id), offset_of!(PhysicalDeviceLayeredApiPropertiesKHR, layered_api), offset_of!(PhysicalDeviceLayeredApiPropertiesKHR, device_name));
    println!("PhysicalDeviceLayeredApiVulkanPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceLayeredApiVulkanPropertiesKHR>(), align_of::<PhysicalDeviceLayeredApiVulkanPropertiesKHR>(), offset_of!(PhysicalDeviceLayeredApiVulkanPropertiesKHR, s_type), offset_of!(PhysicalDeviceLayeredApiVulkanPropertiesKHR, p_next), offset_of!(PhysicalDeviceLayeredApiVulkanPropertiesKHR, properties));
    println!("PhysicalDeviceMaintenance8FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance8FeaturesKHR>(), align_of::<PhysicalDeviceMaintenance8FeaturesKHR>(), offset_of!(PhysicalDeviceMaintenance8FeaturesKHR, s_type), offset_of!(PhysicalDeviceMaintenance8FeaturesKHR, p_next), offset_of!(PhysicalDeviceMaintenance8FeaturesKHR, maintenance8));
    println!("PhysicalDeviceMaintenance9FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance9FeaturesKHR>(), align_of::<PhysicalDeviceMaintenance9FeaturesKHR>(), offset_of!(PhysicalDeviceMaintenance9FeaturesKHR, s_type), offset_of!(PhysicalDeviceMaintenance9FeaturesKHR, p_next), offset_of!(PhysicalDeviceMaintenance9FeaturesKHR, maintenance9));
    println!("PhysicalDeviceMaintenance9PropertiesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance9PropertiesKHR>(), align_of::<PhysicalDeviceMaintenance9PropertiesKHR>(), offset_of!(PhysicalDeviceMaintenance9PropertiesKHR, s_type), offset_of!(PhysicalDeviceMaintenance9PropertiesKHR, p_next), offset_of!(PhysicalDeviceMaintenance9PropertiesKHR, image2_d_view_of3_d_sparse), offset_of!(PhysicalDeviceMaintenance9PropertiesKHR, default_vertex_attribute_value));
    println!("PhysicalDeviceMaintenance10PropertiesKHR {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance10PropertiesKHR>(), align_of::<PhysicalDeviceMaintenance10PropertiesKHR>(), offset_of!(PhysicalDeviceMaintenance10PropertiesKHR, s_type), offset_of!(PhysicalDeviceMaintenance10PropertiesKHR, p_next), offset_of!(PhysicalDeviceMaintenance10PropertiesKHR, rgba4_opaque_black_swizzled), offset_of!(PhysicalDeviceMaintenance10PropertiesKHR, resolve_srgb_format_applies_transfer_function), offset_of!(PhysicalDeviceMaintenance10PropertiesKHR, resolve_srgb_format_supports_transfer_function_control));
    println!("PhysicalDeviceMaintenance10FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceMaintenance10FeaturesKHR>(), align_of::<PhysicalDeviceMaintenance10FeaturesKHR>(), offset_of!(PhysicalDeviceMaintenance10FeaturesKHR, s_type), offset_of!(PhysicalDeviceMaintenance10FeaturesKHR, p_next), offset_of!(PhysicalDeviceMaintenance10FeaturesKHR, maintenance10));
    println!("QueueFamilyOwnershipTransferPropertiesKHR {} {} {} {} {}", size_of::<QueueFamilyOwnershipTransferPropertiesKHR>(), align_of::<QueueFamilyOwnershipTransferPropertiesKHR>(), offset_of!(QueueFamilyOwnershipTransferPropertiesKHR, s_type), offset_of!(QueueFamilyOwnershipTransferPropertiesKHR, p_next), offset_of!(QueueFamilyOwnershipTransferPropertiesKHR, optimal_image_transfer_to_queue_families));
    println!("RenderingAreaInfo {} {} {} {} {} {} {} {} {}", size_of::<RenderingAreaInfo>(), align_of::<RenderingAreaInfo>(), offset_of!(RenderingAreaInfo, s_type), offset_of!(RenderingAreaInfo, p_next), offset_of!(RenderingAreaInfo, view_mask), offset_of!(RenderingAreaInfo, color_attachment_count), offset_of!(RenderingAreaInfo, p_color_attachment_formats), offset_of!(RenderingAreaInfo, depth_attachment_format), offset_of!(RenderingAreaInfo, stencil_attachment_format));
    println!("DescriptorSetLayoutSupport {} {} {} {} {}", size_of::<DescriptorSetLayoutSupport>(), align_of::<DescriptorSetLayoutSupport>(), offset_of!(DescriptorSetLayoutSupport, s_type), offset_of!(DescriptorSetLayoutSupport, p_next), offset_of!(DescriptorSetLayoutSupport, supported));
    println!("PhysicalDeviceShaderDrawParametersFeatures {} {} {} {} {}", size_of::<PhysicalDeviceShaderDrawParametersFeatures>(), align_of::<PhysicalDeviceShaderDrawParametersFeatures>(), offset_of!(PhysicalDeviceShaderDrawParametersFeatures, s_type), offset_of!(PhysicalDeviceShaderDrawParametersFeatures, p_next), offset_of!(PhysicalDeviceShaderDrawParametersFeatures, shader_draw_parameters));
    println!("PhysicalDeviceShaderFloat16Int8Features {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderFloat16Int8Features>(), align_of::<PhysicalDeviceShaderFloat16Int8Features>(), offset_of!(PhysicalDeviceShaderFloat16Int8Features, s_type), offset_of!(PhysicalDeviceShaderFloat16Int8Features, p_next), offset_of!(PhysicalDeviceShaderFloat16Int8Features, shader_float16), offset_of!(PhysicalDeviceShaderFloat16Int8Features, shader_int8));
    println!("PhysicalDeviceFloatControlsProperties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFloatControlsProperties>(), align_of::<PhysicalDeviceFloatControlsProperties>(), offset_of!(PhysicalDeviceFloatControlsProperties, s_type), offset_of!(PhysicalDeviceFloatControlsProperties, p_next), offset_of!(PhysicalDeviceFloatControlsProperties, denorm_behavior_independence), offset_of!(PhysicalDeviceFloatControlsProperties, rounding_mode_independence), offset_of!(PhysicalDeviceFloatControlsProperties, shader_signed_zero_inf_nan_preserve_float16), offset_of!(PhysicalDeviceFloatControlsProperties, shader_signed_zero_inf_nan_preserve_float32), offset_of!(PhysicalDeviceFloatControlsProperties, shader_signed_zero_inf_nan_preserve_float64), offset_of!(PhysicalDeviceFloatControlsProperties, shader_denorm_preserve_float16), offset_of!(PhysicalDeviceFloatControlsProperties, shader_denorm_preserve_float32), offset_of!(PhysicalDeviceFloatControlsProperties, shader_denorm_preserve_float64), offset_of!(PhysicalDeviceFloatControlsProperties, shader_denorm_flush_to_zero_float16), offset_of!(PhysicalDeviceFloatControlsProperties, shader_denorm_flush_to_zero_float32), offset_of!(PhysicalDeviceFloatControlsProperties, shader_denorm_flush_to_zero_float64), offset_of!(PhysicalDeviceFloatControlsProperties, shader_rounding_mode_rte_float16), offset_of!(PhysicalDeviceFloatControlsProperties, shader_rounding_mode_rte_float32), offset_of!(PhysicalDeviceFloatControlsProperties, shader_rounding_mode_rte_float64), offset_of!(PhysicalDeviceFloatControlsProperties, shader_rounding_mode_rtz_float16), offset_of!(PhysicalDeviceFloatControlsProperties, shader_rounding_mode_rtz_float32), offset_of!(PhysicalDeviceFloatControlsProperties, shader_rounding_mode_rtz_float64));
    println!("PhysicalDeviceHostQueryResetFeatures {} {} {} {} {}", size_of::<PhysicalDeviceHostQueryResetFeatures>(), align_of::<PhysicalDeviceHostQueryResetFeatures>(), offset_of!(PhysicalDeviceHostQueryResetFeatures, s_type), offset_of!(PhysicalDeviceHostQueryResetFeatures, p_next), offset_of!(PhysicalDeviceHostQueryResetFeatures, host_query_reset));
    println!("ShaderResourceUsageAMD {} {} {} {} {} {} {}", size_of::<ShaderResourceUsageAMD>(), align_of::<ShaderResourceUsageAMD>(), offset_of!(ShaderResourceUsageAMD, num_used_vgprs), offset_of!(ShaderResourceUsageAMD, num_used_sgprs), offset_of!(ShaderResourceUsageAMD, lds_size_per_local_work_group), offset_of!(ShaderResourceUsageAMD, lds_usage_size_in_bytes), offset_of!(ShaderResourceUsageAMD, scratch_mem_usage_in_bytes));
    println!("ShaderStatisticsInfoAMD {} {} {} {} {} {} {} {} {}", size_of::<ShaderStatisticsInfoAMD>(), align_of::<ShaderStatisticsInfoAMD>(), offset_of!(ShaderStatisticsInfoAMD, shader_stage_mask), offset_of!(ShaderStatisticsInfoAMD, resource_usage), offset_of!(ShaderStatisticsInfoAMD, num_physical_vgprs), offset_of!(ShaderStatisticsInfoAMD, num_physical_sgprs), offset_of!(ShaderStatisticsInfoAMD, num_available_vgprs), offset_of!(ShaderStatisticsInfoAMD, num_available_sgprs), offset_of!(ShaderStatisticsInfoAMD, compute_work_group_size));
    println!("DeviceQueueGlobalPriorityCreateInfo {} {} {} {} {}", size_of::<DeviceQueueGlobalPriorityCreateInfo>(), align_of::<DeviceQueueGlobalPriorityCreateInfo>(), offset_of!(DeviceQueueGlobalPriorityCreateInfo, s_type), offset_of!(DeviceQueueGlobalPriorityCreateInfo, p_next), offset_of!(DeviceQueueGlobalPriorityCreateInfo, global_priority));
    println!("PhysicalDeviceGlobalPriorityQueryFeatures {} {} {} {} {}", size_of::<PhysicalDeviceGlobalPriorityQueryFeatures>(), align_of::<PhysicalDeviceGlobalPriorityQueryFeatures>(), offset_of!(PhysicalDeviceGlobalPriorityQueryFeatures, s_type), offset_of!(PhysicalDeviceGlobalPriorityQueryFeatures, p_next), offset_of!(PhysicalDeviceGlobalPriorityQueryFeatures, global_priority_query));
    println!("QueueFamilyGlobalPriorityProperties {} {} {} {} {} {}", size_of::<QueueFamilyGlobalPriorityProperties>(), align_of::<QueueFamilyGlobalPriorityProperties>(), offset_of!(QueueFamilyGlobalPriorityProperties, s_type), offset_of!(QueueFamilyGlobalPriorityProperties, p_next), offset_of!(QueueFamilyGlobalPriorityProperties, priority_count), offset_of!(QueueFamilyGlobalPriorityProperties, priorities));
    println!("DebugUtilsObjectNameInfoEXT {} {} {} {} {} {} {}", size_of::<DebugUtilsObjectNameInfoEXT>(), align_of::<DebugUtilsObjectNameInfoEXT>(), offset_of!(DebugUtilsObjectNameInfoEXT, s_type), offset_of!(DebugUtilsObjectNameInfoEXT, p_next), offset_of!(DebugUtilsObjectNameInfoEXT, object_type), offset_of!(DebugUtilsObjectNameInfoEXT, object_handle), offset_of!(DebugUtilsObjectNameInfoEXT, p_object_name));
    println!("DebugUtilsObjectTagInfoEXT {} {} {} {} {} {} {} {} {}", size_of::<DebugUtilsObjectTagInfoEXT>(), align_of::<DebugUtilsObjectTagInfoEXT>(), offset_of!(DebugUtilsObjectTagInfoEXT, s_type), offset_of!(DebugUtilsObjectTagInfoEXT, p_next), offset_of!(DebugUtilsObjectTagInfoEXT, object_type), offset_of!(DebugUtilsObjectTagInfoEXT, object_handle), offset_of!(DebugUtilsObjectTagInfoEXT, tag_name), offset_of!(DebugUtilsObjectTagInfoEXT, tag_size), offset_of!(DebugUtilsObjectTagInfoEXT, p_tag));
    println!("DebugUtilsLabelEXT {} {} {} {} {} {}", size_of::<DebugUtilsLabelEXT>(), align_of::<DebugUtilsLabelEXT>(), offset_of!(DebugUtilsLabelEXT, s_type), offset_of!(DebugUtilsLabelEXT, p_next), offset_of!(DebugUtilsLabelEXT, p_label_name), offset_of!(DebugUtilsLabelEXT, color));
    println!("DebugUtilsMessengerCreateInfoEXT {} {} {} {} {} {} {} {} {}", size_of::<DebugUtilsMessengerCreateInfoEXT>(), align_of::<DebugUtilsMessengerCreateInfoEXT>(), offset_of!(DebugUtilsMessengerCreateInfoEXT, s_type), offset_of!(DebugUtilsMessengerCreateInfoEXT, p_next), offset_of!(DebugUtilsMessengerCreateInfoEXT, flags), offset_of!(DebugUtilsMessengerCreateInfoEXT, message_severity), offset_of!(DebugUtilsMessengerCreateInfoEXT, message_type), offset_of!(DebugUtilsMessengerCreateInfoEXT, pfn_user_callback), offset_of!(DebugUtilsMessengerCreateInfoEXT, p_user_data));
    println!("DebugUtilsMessengerCallbackDataEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DebugUtilsMessengerCallbackDataEXT>(), align_of::<DebugUtilsMessengerCallbackDataEXT>(), offset_of!(DebugUtilsMessengerCallbackDataEXT, s_type), offset_of!(DebugUtilsMessengerCallbackDataEXT, p_next), offset_of!(DebugUtilsMessengerCallbackDataEXT, flags), offset_of!(DebugUtilsMessengerCallbackDataEXT, p_message_id_name), offset_of!(DebugUtilsMessengerCallbackDataEXT, message_id_number), offset_of!(DebugUtilsMessengerCallbackDataEXT, p_message), offset_of!(DebugUtilsMessengerCallbackDataEXT, queue_label_count), offset_of!(DebugUtilsMessengerCallbackDataEXT, p_queue_labels), offset_of!(DebugUtilsMessengerCallbackDataEXT, cmd_buf_label_count), offset_of!(DebugUtilsMessengerCallbackDataEXT, p_cmd_buf_labels), offset_of!(DebugUtilsMessengerCallbackDataEXT, object_count), offset_of!(DebugUtilsMessengerCallbackDataEXT, p_objects));
    println!("PhysicalDeviceDeviceMemoryReportFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDeviceMemoryReportFeaturesEXT>(), align_of::<PhysicalDeviceDeviceMemoryReportFeaturesEXT>(), offset_of!(PhysicalDeviceDeviceMemoryReportFeaturesEXT, s_type), offset_of!(PhysicalDeviceDeviceMemoryReportFeaturesEXT, p_next), offset_of!(PhysicalDeviceDeviceMemoryReportFeaturesEXT, device_memory_report));
    println!("DeviceDeviceMemoryReportCreateInfoEXT {} {} {} {} {} {} {}", size_of::<DeviceDeviceMemoryReportCreateInfoEXT>(), align_of::<DeviceDeviceMemoryReportCreateInfoEXT>(), offset_of!(DeviceDeviceMemoryReportCreateInfoEXT, s_type), offset_of!(DeviceDeviceMemoryReportCreateInfoEXT, p_next), offset_of!(DeviceDeviceMemoryReportCreateInfoEXT, flags), offset_of!(DeviceDeviceMemoryReportCreateInfoEXT, pfn_user_callback), offset_of!(DeviceDeviceMemoryReportCreateInfoEXT, p_user_data));
    println!("DeviceMemoryReportCallbackDataEXT {} {} {} {} {} {} {} {} {} {}", size_of::<DeviceMemoryReportCallbackDataEXT>(), align_of::<DeviceMemoryReportCallbackDataEXT>(), offset_of!(DeviceMemoryReportCallbackDataEXT, s_type), offset_of!(DeviceMemoryReportCallbackDataEXT, p_next), offset_of!(DeviceMemoryReportCallbackDataEXT, flags), offset_of!(DeviceMemoryReportCallbackDataEXT, memory_object_id), offset_of!(DeviceMemoryReportCallbackDataEXT, size), offset_of!(DeviceMemoryReportCallbackDataEXT, object_type), offset_of!(DeviceMemoryReportCallbackDataEXT, object_handle), offset_of!(DeviceMemoryReportCallbackDataEXT, heap_index));
    println!("ImportMemoryHostPointerInfoEXT {} {} {} {} {} {}", size_of::<ImportMemoryHostPointerInfoEXT>(), align_of::<ImportMemoryHostPointerInfoEXT>(), offset_of!(ImportMemoryHostPointerInfoEXT, s_type), offset_of!(ImportMemoryHostPointerInfoEXT, p_next), offset_of!(ImportMemoryHostPointerInfoEXT, handle_type), offset_of!(ImportMemoryHostPointerInfoEXT, p_host_pointer));
    println!("MemoryHostPointerPropertiesEXT {} {} {} {} {}", size_of::<MemoryHostPointerPropertiesEXT>(), align_of::<MemoryHostPointerPropertiesEXT>(), offset_of!(MemoryHostPointerPropertiesEXT, s_type), offset_of!(MemoryHostPointerPropertiesEXT, p_next), offset_of!(MemoryHostPointerPropertiesEXT, memory_type_bits));
    println!("PhysicalDeviceExternalMemoryHostPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceExternalMemoryHostPropertiesEXT>(), align_of::<PhysicalDeviceExternalMemoryHostPropertiesEXT>(), offset_of!(PhysicalDeviceExternalMemoryHostPropertiesEXT, s_type), offset_of!(PhysicalDeviceExternalMemoryHostPropertiesEXT, p_next), offset_of!(PhysicalDeviceExternalMemoryHostPropertiesEXT, min_imported_host_pointer_alignment));
    println!("PhysicalDeviceConservativeRasterizationPropertiesEXT {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceConservativeRasterizationPropertiesEXT>(), align_of::<PhysicalDeviceConservativeRasterizationPropertiesEXT>(), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, s_type), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, p_next), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, primitive_overestimation_size), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, max_extra_primitive_overestimation_size), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, extra_primitive_overestimation_size_granularity), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, primitive_underestimation), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, conservative_point_and_line_rasterization), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, degenerate_triangles_rasterized), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, degenerate_lines_rasterized), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, fully_covered_fragment_shader_input_variable), offset_of!(PhysicalDeviceConservativeRasterizationPropertiesEXT, conservative_rasterization_post_depth_coverage));
    println!("CalibratedTimestampInfoKHR {} {} {} {} {}", size_of::<CalibratedTimestampInfoKHR>(), align_of::<CalibratedTimestampInfoKHR>(), offset_of!(CalibratedTimestampInfoKHR, s_type), offset_of!(CalibratedTimestampInfoKHR, p_next), offset_of!(CalibratedTimestampInfoKHR, time_domain));
    println!("PhysicalDeviceShaderCorePropertiesAMD {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderCorePropertiesAMD>(), align_of::<PhysicalDeviceShaderCorePropertiesAMD>(), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, s_type), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, p_next), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, shader_engine_count), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, shader_arrays_per_engine_count), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, compute_units_per_shader_array), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, simd_per_compute_unit), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, wavefronts_per_simd), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, wavefront_size), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, sgprs_per_simd), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, min_sgpr_allocation), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, max_sgpr_allocation), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, sgpr_allocation_granularity), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, vgprs_per_simd), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, min_vgpr_allocation), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, max_vgpr_allocation), offset_of!(PhysicalDeviceShaderCorePropertiesAMD, vgpr_allocation_granularity));
    println!("PhysicalDeviceShaderCoreProperties2AMD {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderCoreProperties2AMD>(), align_of::<PhysicalDeviceShaderCoreProperties2AMD>(), offset_of!(PhysicalDeviceShaderCoreProperties2AMD, s_type), offset_of!(PhysicalDeviceShaderCoreProperties2AMD, p_next), offset_of!(PhysicalDeviceShaderCoreProperties2AMD, shader_core_features), offset_of!(PhysicalDeviceShaderCoreProperties2AMD, active_compute_unit_count));
    println!("PipelineRasterizationConservativeStateCreateInfoEXT {} {} {} {} {} {} {}", size_of::<PipelineRasterizationConservativeStateCreateInfoEXT>(), align_of::<PipelineRasterizationConservativeStateCreateInfoEXT>(), offset_of!(PipelineRasterizationConservativeStateCreateInfoEXT, s_type), offset_of!(PipelineRasterizationConservativeStateCreateInfoEXT, p_next), offset_of!(PipelineRasterizationConservativeStateCreateInfoEXT, flags), offset_of!(PipelineRasterizationConservativeStateCreateInfoEXT, conservative_rasterization_mode), offset_of!(PipelineRasterizationConservativeStateCreateInfoEXT, extra_primitive_overestimation_size));
    println!("PhysicalDeviceDescriptorIndexingFeatures {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorIndexingFeatures>(), align_of::<PhysicalDeviceDescriptorIndexingFeatures>(), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, s_type), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, p_next), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_input_attachment_array_dynamic_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_uniform_texel_buffer_array_dynamic_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_storage_texel_buffer_array_dynamic_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_uniform_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_sampled_image_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_storage_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_storage_image_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_input_attachment_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_uniform_texel_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, shader_storage_texel_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_uniform_buffer_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_sampled_image_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_storage_image_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_storage_buffer_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_uniform_texel_buffer_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_storage_texel_buffer_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_update_unused_while_pending), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_partially_bound), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, descriptor_binding_variable_descriptor_count), offset_of!(PhysicalDeviceDescriptorIndexingFeatures, runtime_descriptor_array));
    println!("PhysicalDeviceDescriptorIndexingProperties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorIndexingProperties>(), align_of::<PhysicalDeviceDescriptorIndexingProperties>(), offset_of!(PhysicalDeviceDescriptorIndexingProperties, s_type), offset_of!(PhysicalDeviceDescriptorIndexingProperties, p_next), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_update_after_bind_descriptors_in_all_pools), offset_of!(PhysicalDeviceDescriptorIndexingProperties, shader_uniform_buffer_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceDescriptorIndexingProperties, shader_sampled_image_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceDescriptorIndexingProperties, shader_storage_buffer_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceDescriptorIndexingProperties, shader_storage_image_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceDescriptorIndexingProperties, shader_input_attachment_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceDescriptorIndexingProperties, robust_buffer_access_update_after_bind), offset_of!(PhysicalDeviceDescriptorIndexingProperties, quad_divergent_implicit_lod), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_descriptor_update_after_bind_samplers), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_descriptor_update_after_bind_uniform_buffers), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_descriptor_update_after_bind_storage_buffers), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_descriptor_update_after_bind_sampled_images), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_descriptor_update_after_bind_storage_images), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_descriptor_update_after_bind_input_attachments), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_per_stage_update_after_bind_resources), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_samplers), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_uniform_buffers), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_uniform_buffers_dynamic), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_storage_buffers), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_storage_buffers_dynamic), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_sampled_images), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_storage_images), offset_of!(PhysicalDeviceDescriptorIndexingProperties, max_descriptor_set_update_after_bind_input_attachments));
    println!("DescriptorSetLayoutBindingFlagsCreateInfo {} {} {} {} {} {}", size_of::<DescriptorSetLayoutBindingFlagsCreateInfo>(), align_of::<DescriptorSetLayoutBindingFlagsCreateInfo>(), offset_of!(DescriptorSetLayoutBindingFlagsCreateInfo, s_type), offset_of!(DescriptorSetLayoutBindingFlagsCreateInfo, p_next), offset_of!(DescriptorSetLayoutBindingFlagsCreateInfo, binding_count), offset_of!(DescriptorSetLayoutBindingFlagsCreateInfo, p_binding_flags));
    println!("DescriptorSetVariableDescriptorCountAllocateInfo {} {} {} {} {} {}", size_of::<DescriptorSetVariableDescriptorCountAllocateInfo>(), align_of::<DescriptorSetVariableDescriptorCountAllocateInfo>(), offset_of!(DescriptorSetVariableDescriptorCountAllocateInfo, s_type), offset_of!(DescriptorSetVariableDescriptorCountAllocateInfo, p_next), offset_of!(DescriptorSetVariableDescriptorCountAllocateInfo, descriptor_set_count), offset_of!(DescriptorSetVariableDescriptorCountAllocateInfo, p_descriptor_counts));
    println!("DescriptorSetVariableDescriptorCountLayoutSupport {} {} {} {} {}", size_of::<DescriptorSetVariableDescriptorCountLayoutSupport>(), align_of::<DescriptorSetVariableDescriptorCountLayoutSupport>(), offset_of!(DescriptorSetVariableDescriptorCountLayoutSupport, s_type), offset_of!(DescriptorSetVariableDescriptorCountLayoutSupport, p_next), offset_of!(DescriptorSetVariableDescriptorCountLayoutSupport, max_variable_descriptor_count));
    println!("AttachmentDescription2 {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<AttachmentDescription2>(), align_of::<AttachmentDescription2>(), offset_of!(AttachmentDescription2, s_type), offset_of!(AttachmentDescription2, p_next), offset_of!(AttachmentDescription2, flags), offset_of!(AttachmentDescription2, format), offset_of!(AttachmentDescription2, samples), offset_of!(AttachmentDescription2, load_op), offset_of!(AttachmentDescription2, store_op), offset_of!(AttachmentDescription2, stencil_load_op), offset_of!(AttachmentDescription2, stencil_store_op), offset_of!(AttachmentDescription2, initial_layout), offset_of!(AttachmentDescription2, final_layout));
    println!("AttachmentReference2 {} {} {} {} {} {} {}", size_of::<AttachmentReference2>(), align_of::<AttachmentReference2>(), offset_of!(AttachmentReference2, s_type), offset_of!(AttachmentReference2, p_next), offset_of!(AttachmentReference2, attachment), offset_of!(AttachmentReference2, layout), offset_of!(AttachmentReference2, aspect_mask));
    println!("SubpassDescription2 {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SubpassDescription2>(), align_of::<SubpassDescription2>(), offset_of!(SubpassDescription2, s_type), offset_of!(SubpassDescription2, p_next), offset_of!(SubpassDescription2, flags), offset_of!(SubpassDescription2, pipeline_bind_point), offset_of!(SubpassDescription2, view_mask), offset_of!(SubpassDescription2, input_attachment_count), offset_of!(SubpassDescription2, p_input_attachments), offset_of!(SubpassDescription2, color_attachment_count), offset_of!(SubpassDescription2, p_color_attachments), offset_of!(SubpassDescription2, p_resolve_attachments), offset_of!(SubpassDescription2, p_depth_stencil_attachment), offset_of!(SubpassDescription2, preserve_attachment_count), offset_of!(SubpassDescription2, p_preserve_attachments));
    println!("SubpassDependency2 {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SubpassDependency2>(), align_of::<SubpassDependency2>(), offset_of!(SubpassDependency2, s_type), offset_of!(SubpassDependency2, p_next), offset_of!(SubpassDependency2, src_subpass), offset_of!(SubpassDependency2, dst_subpass), offset_of!(SubpassDependency2, src_stage_mask), offset_of!(SubpassDependency2, dst_stage_mask), offset_of!(SubpassDependency2, src_access_mask), offset_of!(SubpassDependency2, dst_access_mask), offset_of!(SubpassDependency2, dependency_flags), offset_of!(SubpassDependency2, view_offset));
    println!("RenderPassCreateInfo2 {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<RenderPassCreateInfo2>(), align_of::<RenderPassCreateInfo2>(), offset_of!(RenderPassCreateInfo2, s_type), offset_of!(RenderPassCreateInfo2, p_next), offset_of!(RenderPassCreateInfo2, flags), offset_of!(RenderPassCreateInfo2, attachment_count), offset_of!(RenderPassCreateInfo2, p_attachments), offset_of!(RenderPassCreateInfo2, subpass_count), offset_of!(RenderPassCreateInfo2, p_subpasses), offset_of!(RenderPassCreateInfo2, dependency_count), offset_of!(RenderPassCreateInfo2, p_dependencies), offset_of!(RenderPassCreateInfo2, correlated_view_mask_count), offset_of!(RenderPassCreateInfo2, p_correlated_view_masks));
    println!("SubpassBeginInfo {} {} {} {} {}", size_of::<SubpassBeginInfo>(), align_of::<SubpassBeginInfo>(), offset_of!(SubpassBeginInfo, s_type), offset_of!(SubpassBeginInfo, p_next), offset_of!(SubpassBeginInfo, contents));
    println!("SubpassEndInfo {} {} {} {}", size_of::<SubpassEndInfo>(), align_of::<SubpassEndInfo>(), offset_of!(SubpassEndInfo, s_type), offset_of!(SubpassEndInfo, p_next));
    println!("PhysicalDeviceTimelineSemaphoreFeatures {} {} {} {} {}", size_of::<PhysicalDeviceTimelineSemaphoreFeatures>(), align_of::<PhysicalDeviceTimelineSemaphoreFeatures>(), offset_of!(PhysicalDeviceTimelineSemaphoreFeatures, s_type), offset_of!(PhysicalDeviceTimelineSemaphoreFeatures, p_next), offset_of!(PhysicalDeviceTimelineSemaphoreFeatures, timeline_semaphore));
    println!("PhysicalDeviceTimelineSemaphoreProperties {} {} {} {} {}", size_of::<PhysicalDeviceTimelineSemaphoreProperties>(), align_of::<PhysicalDeviceTimelineSemaphoreProperties>(), offset_of!(PhysicalDeviceTimelineSemaphoreProperties, s_type), offset_of!(PhysicalDeviceTimelineSemaphoreProperties, p_next), offset_of!(PhysicalDeviceTimelineSemaphoreProperties, max_timeline_semaphore_value_difference));
    println!("SemaphoreTypeCreateInfo {} {} {} {} {} {}", size_of::<SemaphoreTypeCreateInfo>(), align_of::<SemaphoreTypeCreateInfo>(), offset_of!(SemaphoreTypeCreateInfo, s_type), offset_of!(SemaphoreTypeCreateInfo, p_next), offset_of!(SemaphoreTypeCreateInfo, semaphore_type), offset_of!(SemaphoreTypeCreateInfo, initial_value));
    println!("TimelineSemaphoreSubmitInfo {} {} {} {} {} {} {} {}", size_of::<TimelineSemaphoreSubmitInfo>(), align_of::<TimelineSemaphoreSubmitInfo>(), offset_of!(TimelineSemaphoreSubmitInfo, s_type), offset_of!(TimelineSemaphoreSubmitInfo, p_next), offset_of!(TimelineSemaphoreSubmitInfo, wait_semaphore_value_count), offset_of!(TimelineSemaphoreSubmitInfo, p_wait_semaphore_values), offset_of!(TimelineSemaphoreSubmitInfo, signal_semaphore_value_count), offset_of!(TimelineSemaphoreSubmitInfo, p_signal_semaphore_values));
    println!("SemaphoreWaitInfo {} {} {} {} {} {} {} {}", size_of::<SemaphoreWaitInfo>(), align_of::<SemaphoreWaitInfo>(), offset_of!(SemaphoreWaitInfo, s_type), offset_of!(SemaphoreWaitInfo, p_next), offset_of!(SemaphoreWaitInfo, flags), offset_of!(SemaphoreWaitInfo, semaphore_count), offset_of!(SemaphoreWaitInfo, p_semaphores), offset_of!(SemaphoreWaitInfo, p_values));
    println!("SemaphoreSignalInfo {} {} {} {} {} {}", size_of::<SemaphoreSignalInfo>(), align_of::<SemaphoreSignalInfo>(), offset_of!(SemaphoreSignalInfo, s_type), offset_of!(SemaphoreSignalInfo, p_next), offset_of!(SemaphoreSignalInfo, semaphore), offset_of!(SemaphoreSignalInfo, value));
    println!("VertexInputBindingDivisorDescription {} {} {} {}", size_of::<VertexInputBindingDivisorDescription>(), align_of::<VertexInputBindingDivisorDescription>(), offset_of!(VertexInputBindingDivisorDescription, binding), offset_of!(VertexInputBindingDivisorDescription, divisor));
    println!("PipelineVertexInputDivisorStateCreateInfo {} {} {} {} {} {}", size_of::<PipelineVertexInputDivisorStateCreateInfo>(), align_of::<PipelineVertexInputDivisorStateCreateInfo>(), offset_of!(PipelineVertexInputDivisorStateCreateInfo, s_type), offset_of!(PipelineVertexInputDivisorStateCreateInfo, p_next), offset_of!(PipelineVertexInputDivisorStateCreateInfo, vertex_binding_divisor_count), offset_of!(PipelineVertexInputDivisorStateCreateInfo, p_vertex_binding_divisors));
    println!("PhysicalDeviceVertexAttributeDivisorPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>(), align_of::<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>(), offset_of!(PhysicalDeviceVertexAttributeDivisorPropertiesEXT, s_type), offset_of!(PhysicalDeviceVertexAttributeDivisorPropertiesEXT, p_next), offset_of!(PhysicalDeviceVertexAttributeDivisorPropertiesEXT, max_vertex_attrib_divisor));
    println!("PhysicalDeviceVertexAttributeDivisorProperties {} {} {} {} {} {}", size_of::<PhysicalDeviceVertexAttributeDivisorProperties>(), align_of::<PhysicalDeviceVertexAttributeDivisorProperties>(), offset_of!(PhysicalDeviceVertexAttributeDivisorProperties, s_type), offset_of!(PhysicalDeviceVertexAttributeDivisorProperties, p_next), offset_of!(PhysicalDeviceVertexAttributeDivisorProperties, max_vertex_attrib_divisor), offset_of!(PhysicalDeviceVertexAttributeDivisorProperties, supports_non_zero_first_instance));
    println!("PhysicalDevicePCIBusInfoPropertiesEXT {} {} {} {} {} {} {} {}", size_of::<PhysicalDevicePCIBusInfoPropertiesEXT>(), align_of::<PhysicalDevicePCIBusInfoPropertiesEXT>(), offset_of!(PhysicalDevicePCIBusInfoPropertiesEXT, s_type), offset_of!(PhysicalDevicePCIBusInfoPropertiesEXT, p_next), offset_of!(PhysicalDevicePCIBusInfoPropertiesEXT, pci_domain), offset_of!(PhysicalDevicePCIBusInfoPropertiesEXT, pci_bus), offset_of!(PhysicalDevicePCIBusInfoPropertiesEXT, pci_device), offset_of!(PhysicalDevicePCIBusInfoPropertiesEXT, pci_function));
    println!("CommandBufferInheritanceConditionalRenderingInfoEXT {} {} {} {} {}", size_of::<CommandBufferInheritanceConditionalRenderingInfoEXT>(), align_of::<CommandBufferInheritanceConditionalRenderingInfoEXT>(), offset_of!(CommandBufferInheritanceConditionalRenderingInfoEXT, s_type), offset_of!(CommandBufferInheritanceConditionalRenderingInfoEXT, p_next), offset_of!(CommandBufferInheritanceConditionalRenderingInfoEXT, conditional_rendering_enable));
    println!("PhysicalDevice8BitStorageFeatures {} {} {} {} {} {} {}", size_of::<PhysicalDevice8BitStorageFeatures>(), align_of::<PhysicalDevice8BitStorageFeatures>(), offset_of!(PhysicalDevice8BitStorageFeatures, s_type), offset_of!(PhysicalDevice8BitStorageFeatures, p_next), offset_of!(PhysicalDevice8BitStorageFeatures, storage_buffer8_bit_access), offset_of!(PhysicalDevice8BitStorageFeatures, uniform_and_storage_buffer8_bit_access), offset_of!(PhysicalDevice8BitStorageFeatures, storage_push_constant8));
    println!("PhysicalDeviceConditionalRenderingFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceConditionalRenderingFeaturesEXT>(), align_of::<PhysicalDeviceConditionalRenderingFeaturesEXT>(), offset_of!(PhysicalDeviceConditionalRenderingFeaturesEXT, s_type), offset_of!(PhysicalDeviceConditionalRenderingFeaturesEXT, p_next), offset_of!(PhysicalDeviceConditionalRenderingFeaturesEXT, conditional_rendering), offset_of!(PhysicalDeviceConditionalRenderingFeaturesEXT, inherited_conditional_rendering));
    println!("PhysicalDeviceVulkanMemoryModelFeatures {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkanMemoryModelFeatures>(), align_of::<PhysicalDeviceVulkanMemoryModelFeatures>(), offset_of!(PhysicalDeviceVulkanMemoryModelFeatures, s_type), offset_of!(PhysicalDeviceVulkanMemoryModelFeatures, p_next), offset_of!(PhysicalDeviceVulkanMemoryModelFeatures, vulkan_memory_model), offset_of!(PhysicalDeviceVulkanMemoryModelFeatures, vulkan_memory_model_device_scope), offset_of!(PhysicalDeviceVulkanMemoryModelFeatures, vulkan_memory_model_availability_visibility_chains));
    println!("PhysicalDeviceShaderAtomicInt64Features {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderAtomicInt64Features>(), align_of::<PhysicalDeviceShaderAtomicInt64Features>(), offset_of!(PhysicalDeviceShaderAtomicInt64Features, s_type), offset_of!(PhysicalDeviceShaderAtomicInt64Features, p_next), offset_of!(PhysicalDeviceShaderAtomicInt64Features, shader_buffer_int64_atomics), offset_of!(PhysicalDeviceShaderAtomicInt64Features, shader_shared_int64_atomics));
    println!("PhysicalDeviceShaderAtomicFloatFeaturesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderAtomicFloatFeaturesEXT>(), align_of::<PhysicalDeviceShaderAtomicFloatFeaturesEXT>(), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_buffer_float32_atomics), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_buffer_float32_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_buffer_float64_atomics), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_buffer_float64_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_shared_float32_atomics), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_shared_float32_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_shared_float64_atomics), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_shared_float64_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_image_float32_atomics), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, shader_image_float32_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, sparse_image_float32_atomics), offset_of!(PhysicalDeviceShaderAtomicFloatFeaturesEXT, sparse_image_float32_atomic_add));
    println!("PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderAtomicFloat2FeaturesEXT>(), align_of::<PhysicalDeviceShaderAtomicFloat2FeaturesEXT>(), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_buffer_float16_atomics), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_buffer_float16_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_buffer_float16_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_buffer_float32_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_buffer_float64_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_shared_float16_atomics), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_shared_float16_atomic_add), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_shared_float16_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_shared_float32_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_shared_float64_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, shader_image_float32_atomic_min_max), offset_of!(PhysicalDeviceShaderAtomicFloat2FeaturesEXT, sparse_image_float32_atomic_min_max));
    println!("PhysicalDeviceVertexAttributeDivisorFeatures {} {} {} {} {} {}", size_of::<PhysicalDeviceVertexAttributeDivisorFeatures>(), align_of::<PhysicalDeviceVertexAttributeDivisorFeatures>(), offset_of!(PhysicalDeviceVertexAttributeDivisorFeatures, s_type), offset_of!(PhysicalDeviceVertexAttributeDivisorFeatures, p_next), offset_of!(PhysicalDeviceVertexAttributeDivisorFeatures, vertex_attribute_instance_rate_divisor), offset_of!(PhysicalDeviceVertexAttributeDivisorFeatures, vertex_attribute_instance_rate_zero_divisor));
    println!("QueueFamilyCheckpointPropertiesNV {} {} {} {} {}", size_of::<QueueFamilyCheckpointPropertiesNV>(), align_of::<QueueFamilyCheckpointPropertiesNV>(), offset_of!(QueueFamilyCheckpointPropertiesNV, s_type), offset_of!(QueueFamilyCheckpointPropertiesNV, p_next), offset_of!(QueueFamilyCheckpointPropertiesNV, checkpoint_execution_stage_mask));
    println!("CheckpointDataNV {} {} {} {} {} {}", size_of::<CheckpointDataNV>(), align_of::<CheckpointDataNV>(), offset_of!(CheckpointDataNV, s_type), offset_of!(CheckpointDataNV, p_next), offset_of!(CheckpointDataNV, stage), offset_of!(CheckpointDataNV, p_checkpoint_marker));
    println!("PhysicalDeviceDepthStencilResolveProperties {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDepthStencilResolveProperties>(), align_of::<PhysicalDeviceDepthStencilResolveProperties>(), offset_of!(PhysicalDeviceDepthStencilResolveProperties, s_type), offset_of!(PhysicalDeviceDepthStencilResolveProperties, p_next), offset_of!(PhysicalDeviceDepthStencilResolveProperties, supported_depth_resolve_modes), offset_of!(PhysicalDeviceDepthStencilResolveProperties, supported_stencil_resolve_modes), offset_of!(PhysicalDeviceDepthStencilResolveProperties, independent_resolve_none), offset_of!(PhysicalDeviceDepthStencilResolveProperties, independent_resolve));
    println!("SubpassDescriptionDepthStencilResolve {} {} {} {} {} {} {}", size_of::<SubpassDescriptionDepthStencilResolve>(), align_of::<SubpassDescriptionDepthStencilResolve>(), offset_of!(SubpassDescriptionDepthStencilResolve, s_type), offset_of!(SubpassDescriptionDepthStencilResolve, p_next), offset_of!(SubpassDescriptionDepthStencilResolve, depth_resolve_mode), offset_of!(SubpassDescriptionDepthStencilResolve, stencil_resolve_mode), offset_of!(SubpassDescriptionDepthStencilResolve, p_depth_stencil_resolve_attachment));
    println!("ImageViewASTCDecodeModeEXT {} {} {} {} {}", size_of::<ImageViewASTCDecodeModeEXT>(), align_of::<ImageViewASTCDecodeModeEXT>(), offset_of!(ImageViewASTCDecodeModeEXT, s_type), offset_of!(ImageViewASTCDecodeModeEXT, p_next), offset_of!(ImageViewASTCDecodeModeEXT, decode_mode));
    println!("PhysicalDeviceASTCDecodeFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceASTCDecodeFeaturesEXT>(), align_of::<PhysicalDeviceASTCDecodeFeaturesEXT>(), offset_of!(PhysicalDeviceASTCDecodeFeaturesEXT, s_type), offset_of!(PhysicalDeviceASTCDecodeFeaturesEXT, p_next), offset_of!(PhysicalDeviceASTCDecodeFeaturesEXT, decode_mode_shared_exponent));
    println!("PhysicalDeviceTransformFeedbackFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceTransformFeedbackFeaturesEXT>(), align_of::<PhysicalDeviceTransformFeedbackFeaturesEXT>(), offset_of!(PhysicalDeviceTransformFeedbackFeaturesEXT, s_type), offset_of!(PhysicalDeviceTransformFeedbackFeaturesEXT, p_next), offset_of!(PhysicalDeviceTransformFeedbackFeaturesEXT, transform_feedback), offset_of!(PhysicalDeviceTransformFeedbackFeaturesEXT, geometry_streams));
    println!("PhysicalDeviceTransformFeedbackPropertiesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceTransformFeedbackPropertiesEXT>(), align_of::<PhysicalDeviceTransformFeedbackPropertiesEXT>(), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, s_type), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, p_next), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, max_transform_feedback_streams), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, max_transform_feedback_buffers), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, max_transform_feedback_buffer_size), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, max_transform_feedback_stream_data_size), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, max_transform_feedback_buffer_data_size), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, max_transform_feedback_buffer_data_stride), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, transform_feedback_queries), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, transform_feedback_streams_lines_triangles), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, transform_feedback_rasterization_stream_select), offset_of!(PhysicalDeviceTransformFeedbackPropertiesEXT, transform_feedback_draw));
    println!("PipelineRasterizationStateStreamCreateInfoEXT {} {} {} {} {} {}", size_of::<PipelineRasterizationStateStreamCreateInfoEXT>(), align_of::<PipelineRasterizationStateStreamCreateInfoEXT>(), offset_of!(PipelineRasterizationStateStreamCreateInfoEXT, s_type), offset_of!(PipelineRasterizationStateStreamCreateInfoEXT, p_next), offset_of!(PipelineRasterizationStateStreamCreateInfoEXT, flags), offset_of!(PipelineRasterizationStateStreamCreateInfoEXT, rasterization_stream));
    println!("PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>(), align_of::<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>(), offset_of!(PhysicalDeviceRepresentativeFragmentTestFeaturesNV, s_type), offset_of!(PhysicalDeviceRepresentativeFragmentTestFeaturesNV, p_next), offset_of!(PhysicalDeviceRepresentativeFragmentTestFeaturesNV, representative_fragment_test));
    println!("PipelineRepresentativeFragmentTestStateCreateInfoNV {} {} {} {} {}", size_of::<PipelineRepresentativeFragmentTestStateCreateInfoNV>(), align_of::<PipelineRepresentativeFragmentTestStateCreateInfoNV>(), offset_of!(PipelineRepresentativeFragmentTestStateCreateInfoNV, s_type), offset_of!(PipelineRepresentativeFragmentTestStateCreateInfoNV, p_next), offset_of!(PipelineRepresentativeFragmentTestStateCreateInfoNV, representative_fragment_test_enable));
    println!("PhysicalDeviceExclusiveScissorFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceExclusiveScissorFeaturesNV>(), align_of::<PhysicalDeviceExclusiveScissorFeaturesNV>(), offset_of!(PhysicalDeviceExclusiveScissorFeaturesNV, s_type), offset_of!(PhysicalDeviceExclusiveScissorFeaturesNV, p_next), offset_of!(PhysicalDeviceExclusiveScissorFeaturesNV, exclusive_scissor));
    println!("PipelineViewportExclusiveScissorStateCreateInfoNV {} {} {} {} {} {}", size_of::<PipelineViewportExclusiveScissorStateCreateInfoNV>(), align_of::<PipelineViewportExclusiveScissorStateCreateInfoNV>(), offset_of!(PipelineViewportExclusiveScissorStateCreateInfoNV, s_type), offset_of!(PipelineViewportExclusiveScissorStateCreateInfoNV, p_next), offset_of!(PipelineViewportExclusiveScissorStateCreateInfoNV, exclusive_scissor_count), offset_of!(PipelineViewportExclusiveScissorStateCreateInfoNV, p_exclusive_scissors));
    println!("PhysicalDeviceCornerSampledImageFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceCornerSampledImageFeaturesNV>(), align_of::<PhysicalDeviceCornerSampledImageFeaturesNV>(), offset_of!(PhysicalDeviceCornerSampledImageFeaturesNV, s_type), offset_of!(PhysicalDeviceCornerSampledImageFeaturesNV, p_next), offset_of!(PhysicalDeviceCornerSampledImageFeaturesNV, corner_sampled_image));
    println!("PhysicalDeviceComputeShaderDerivativesFeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceComputeShaderDerivativesFeaturesKHR>(), align_of::<PhysicalDeviceComputeShaderDerivativesFeaturesKHR>(), offset_of!(PhysicalDeviceComputeShaderDerivativesFeaturesKHR, s_type), offset_of!(PhysicalDeviceComputeShaderDerivativesFeaturesKHR, p_next), offset_of!(PhysicalDeviceComputeShaderDerivativesFeaturesKHR, compute_derivative_group_quads), offset_of!(PhysicalDeviceComputeShaderDerivativesFeaturesKHR, compute_derivative_group_linear));
    println!("PhysicalDeviceComputeShaderDerivativesPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceComputeShaderDerivativesPropertiesKHR>(), align_of::<PhysicalDeviceComputeShaderDerivativesPropertiesKHR>(), offset_of!(PhysicalDeviceComputeShaderDerivativesPropertiesKHR, s_type), offset_of!(PhysicalDeviceComputeShaderDerivativesPropertiesKHR, p_next), offset_of!(PhysicalDeviceComputeShaderDerivativesPropertiesKHR, mesh_and_task_shader_derivatives));
    println!("PhysicalDeviceShaderImageFootprintFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceShaderImageFootprintFeaturesNV>(), align_of::<PhysicalDeviceShaderImageFootprintFeaturesNV>(), offset_of!(PhysicalDeviceShaderImageFootprintFeaturesNV, s_type), offset_of!(PhysicalDeviceShaderImageFootprintFeaturesNV, p_next), offset_of!(PhysicalDeviceShaderImageFootprintFeaturesNV, image_footprint));
    println!("PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(), align_of::<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(), offset_of!(PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, s_type), offset_of!(PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, p_next), offset_of!(PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, dedicated_allocation_image_aliasing));
    println!("PhysicalDeviceCopyMemoryIndirectFeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceCopyMemoryIndirectFeaturesKHR>(), align_of::<PhysicalDeviceCopyMemoryIndirectFeaturesKHR>(), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesKHR, s_type), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesKHR, p_next), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesKHR, indirect_memory_copy), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesKHR, indirect_memory_to_image_copy));
    println!("PhysicalDeviceCopyMemoryIndirectFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceCopyMemoryIndirectFeaturesNV>(), align_of::<PhysicalDeviceCopyMemoryIndirectFeaturesNV>(), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesNV, s_type), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesNV, p_next), offset_of!(PhysicalDeviceCopyMemoryIndirectFeaturesNV, indirect_copy));
    println!("PhysicalDeviceCopyMemoryIndirectPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceCopyMemoryIndirectPropertiesKHR>(), align_of::<PhysicalDeviceCopyMemoryIndirectPropertiesKHR>(), offset_of!(PhysicalDeviceCopyMemoryIndirectPropertiesKHR, s_type), offset_of!(PhysicalDeviceCopyMemoryIndirectPropertiesKHR, p_next), offset_of!(PhysicalDeviceCopyMemoryIndirectPropertiesKHR, supported_queues));
    println!("PhysicalDeviceMemoryDecompressionFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMemoryDecompressionFeaturesEXT>(), align_of::<PhysicalDeviceMemoryDecompressionFeaturesEXT>(), offset_of!(PhysicalDeviceMemoryDecompressionFeaturesEXT, s_type), offset_of!(PhysicalDeviceMemoryDecompressionFeaturesEXT, p_next), offset_of!(PhysicalDeviceMemoryDecompressionFeaturesEXT, memory_decompression));
    println!("PhysicalDeviceMemoryDecompressionPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceMemoryDecompressionPropertiesEXT>(), align_of::<PhysicalDeviceMemoryDecompressionPropertiesEXT>(), offset_of!(PhysicalDeviceMemoryDecompressionPropertiesEXT, s_type), offset_of!(PhysicalDeviceMemoryDecompressionPropertiesEXT, p_next), offset_of!(PhysicalDeviceMemoryDecompressionPropertiesEXT, decompression_methods), offset_of!(PhysicalDeviceMemoryDecompressionPropertiesEXT, max_decompression_indirect_count));
    println!("ShadingRatePaletteNV {} {} {} {}", size_of::<ShadingRatePaletteNV>(), align_of::<ShadingRatePaletteNV>(), offset_of!(ShadingRatePaletteNV, shading_rate_palette_entry_count), offset_of!(ShadingRatePaletteNV, p_shading_rate_palette_entries));
    println!("PipelineViewportShadingRateImageStateCreateInfoNV {} {} {} {} {} {} {}", size_of::<PipelineViewportShadingRateImageStateCreateInfoNV>(), align_of::<PipelineViewportShadingRateImageStateCreateInfoNV>(), offset_of!(PipelineViewportShadingRateImageStateCreateInfoNV, s_type), offset_of!(PipelineViewportShadingRateImageStateCreateInfoNV, p_next), offset_of!(PipelineViewportShadingRateImageStateCreateInfoNV, shading_rate_image_enable), offset_of!(PipelineViewportShadingRateImageStateCreateInfoNV, viewport_count), offset_of!(PipelineViewportShadingRateImageStateCreateInfoNV, p_shading_rate_palettes));
    println!("PhysicalDeviceShadingRateImageFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceShadingRateImageFeaturesNV>(), align_of::<PhysicalDeviceShadingRateImageFeaturesNV>(), offset_of!(PhysicalDeviceShadingRateImageFeaturesNV, s_type), offset_of!(PhysicalDeviceShadingRateImageFeaturesNV, p_next), offset_of!(PhysicalDeviceShadingRateImageFeaturesNV, shading_rate_image), offset_of!(PhysicalDeviceShadingRateImageFeaturesNV, shading_rate_coarse_sample_order));
    println!("PhysicalDeviceShadingRateImagePropertiesNV {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShadingRateImagePropertiesNV>(), align_of::<PhysicalDeviceShadingRateImagePropertiesNV>(), offset_of!(PhysicalDeviceShadingRateImagePropertiesNV, s_type), offset_of!(PhysicalDeviceShadingRateImagePropertiesNV, p_next), offset_of!(PhysicalDeviceShadingRateImagePropertiesNV, shading_rate_texel_size), offset_of!(PhysicalDeviceShadingRateImagePropertiesNV, shading_rate_palette_size), offset_of!(PhysicalDeviceShadingRateImagePropertiesNV, shading_rate_max_coarse_samples));
    println!("PhysicalDeviceInvocationMaskFeaturesHUAWEI {} {} {} {} {}", size_of::<PhysicalDeviceInvocationMaskFeaturesHUAWEI>(), align_of::<PhysicalDeviceInvocationMaskFeaturesHUAWEI>(), offset_of!(PhysicalDeviceInvocationMaskFeaturesHUAWEI, s_type), offset_of!(PhysicalDeviceInvocationMaskFeaturesHUAWEI, p_next), offset_of!(PhysicalDeviceInvocationMaskFeaturesHUAWEI, invocation_mask));
    println!("CoarseSampleLocationNV {} {} {} {} {}", size_of::<CoarseSampleLocationNV>(), align_of::<CoarseSampleLocationNV>(), offset_of!(CoarseSampleLocationNV, pixel_x), offset_of!(CoarseSampleLocationNV, pixel_y), offset_of!(CoarseSampleLocationNV, sample));
    println!("CoarseSampleOrderCustomNV {} {} {} {} {} {}", size_of::<CoarseSampleOrderCustomNV>(), align_of::<CoarseSampleOrderCustomNV>(), offset_of!(CoarseSampleOrderCustomNV, shading_rate), offset_of!(CoarseSampleOrderCustomNV, sample_count), offset_of!(CoarseSampleOrderCustomNV, sample_location_count), offset_of!(CoarseSampleOrderCustomNV, p_sample_locations));
    println!("PipelineViewportCoarseSampleOrderStateCreateInfoNV {} {} {} {} {} {} {}", size_of::<PipelineViewportCoarseSampleOrderStateCreateInfoNV>(), align_of::<PipelineViewportCoarseSampleOrderStateCreateInfoNV>(), offset_of!(PipelineViewportCoarseSampleOrderStateCreateInfoNV, s_type), offset_of!(PipelineViewportCoarseSampleOrderStateCreateInfoNV, p_next), offset_of!(PipelineViewportCoarseSampleOrderStateCreateInfoNV, sample_order_type), offset_of!(PipelineViewportCoarseSampleOrderStateCreateInfoNV, custom_sample_order_count), offset_of!(PipelineViewportCoarseSampleOrderStateCreateInfoNV, p_custom_sample_orders));
    println!("PhysicalDeviceMeshShaderFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceMeshShaderFeaturesNV>(), align_of::<PhysicalDeviceMeshShaderFeaturesNV>(), offset_of!(PhysicalDeviceMeshShaderFeaturesNV, s_type), offset_of!(PhysicalDeviceMeshShaderFeaturesNV, p_next), offset_of!(PhysicalDeviceMeshShaderFeaturesNV, task_shader), offset_of!(PhysicalDeviceMeshShaderFeaturesNV, mesh_shader));
    println!("PhysicalDeviceMeshShaderPropertiesNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMeshShaderPropertiesNV>(), align_of::<PhysicalDeviceMeshShaderPropertiesNV>(), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, s_type), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, p_next), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_draw_mesh_tasks_count), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_task_work_group_invocations), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_task_work_group_size), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_task_total_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_task_output_count), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_mesh_work_group_invocations), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_mesh_work_group_size), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_mesh_total_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_mesh_output_vertices), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_mesh_output_primitives), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, max_mesh_multiview_view_count), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, mesh_output_per_vertex_granularity), offset_of!(PhysicalDeviceMeshShaderPropertiesNV, mesh_output_per_primitive_granularity));
    println!("DrawMeshTasksIndirectCommandNV {} {} {} {}", size_of::<DrawMeshTasksIndirectCommandNV>(), align_of::<DrawMeshTasksIndirectCommandNV>(), offset_of!(DrawMeshTasksIndirectCommandNV, task_count), offset_of!(DrawMeshTasksIndirectCommandNV, first_task));
    println!("PhysicalDeviceMeshShaderFeaturesEXT {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMeshShaderFeaturesEXT>(), align_of::<PhysicalDeviceMeshShaderFeaturesEXT>(), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, s_type), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, p_next), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, task_shader), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, mesh_shader), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, multiview_mesh_shader), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, primitive_fragment_shading_rate_mesh_shader), offset_of!(PhysicalDeviceMeshShaderFeaturesEXT, mesh_shader_queries));
    println!("PhysicalDeviceMeshShaderPropertiesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMeshShaderPropertiesEXT>(), align_of::<PhysicalDeviceMeshShaderPropertiesEXT>(), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, s_type), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, p_next), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_work_group_total_count), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_work_group_count), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_work_group_invocations), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_work_group_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_payload_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_shared_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_task_payload_and_shared_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_work_group_total_count), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_work_group_count), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_work_group_invocations), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_work_group_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_shared_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_payload_and_shared_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_output_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_payload_and_output_memory_size), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_output_components), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_output_vertices), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_output_primitives), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_output_layers), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_mesh_multiview_view_count), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, mesh_output_per_vertex_granularity), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, mesh_output_per_primitive_granularity), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_preferred_task_work_group_invocations), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, max_preferred_mesh_work_group_invocations), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, prefers_local_invocation_vertex_output), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, prefers_local_invocation_primitive_output), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, prefers_compact_vertex_output), offset_of!(PhysicalDeviceMeshShaderPropertiesEXT, prefers_compact_primitive_output));
    println!("DrawMeshTasksIndirectCommandEXT {} {} {} {} {}", size_of::<DrawMeshTasksIndirectCommandEXT>(), align_of::<DrawMeshTasksIndirectCommandEXT>(), offset_of!(DrawMeshTasksIndirectCommandEXT, group_count_x), offset_of!(DrawMeshTasksIndirectCommandEXT, group_count_y), offset_of!(DrawMeshTasksIndirectCommandEXT, group_count_z));
    println!("RayTracingShaderGroupCreateInfoNV {} {} {} {} {} {} {} {}", size_of::<RayTracingShaderGroupCreateInfoNV>(), align_of::<RayTracingShaderGroupCreateInfoNV>(), offset_of!(RayTracingShaderGroupCreateInfoNV, s_type), offset_of!(RayTracingShaderGroupCreateInfoNV, p_next), offset_of!(RayTracingShaderGroupCreateInfoNV, general_shader), offset_of!(RayTracingShaderGroupCreateInfoNV, closest_hit_shader), offset_of!(RayTracingShaderGroupCreateInfoNV, any_hit_shader), offset_of!(RayTracingShaderGroupCreateInfoNV, intersection_shader));
    println!("RayTracingShaderGroupCreateInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<RayTracingShaderGroupCreateInfoKHR>(), align_of::<RayTracingShaderGroupCreateInfoKHR>(), offset_of!(RayTracingShaderGroupCreateInfoKHR, s_type), offset_of!(RayTracingShaderGroupCreateInfoKHR, p_next), offset_of!(RayTracingShaderGroupCreateInfoKHR, general_shader), offset_of!(RayTracingShaderGroupCreateInfoKHR, closest_hit_shader), offset_of!(RayTracingShaderGroupCreateInfoKHR, any_hit_shader), offset_of!(RayTracingShaderGroupCreateInfoKHR, intersection_shader), offset_of!(RayTracingShaderGroupCreateInfoKHR, p_shader_group_capture_replay_handle));
    println!("RayTracingPipelineCreateInfoNV {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<RayTracingPipelineCreateInfoNV>(), align_of::<RayTracingPipelineCreateInfoNV>(), offset_of!(RayTracingPipelineCreateInfoNV, s_type), offset_of!(RayTracingPipelineCreateInfoNV, p_next), offset_of!(RayTracingPipelineCreateInfoNV, flags), offset_of!(RayTracingPipelineCreateInfoNV, stage_count), offset_of!(RayTracingPipelineCreateInfoNV, p_stages), offset_of!(RayTracingPipelineCreateInfoNV, group_count), offset_of!(RayTracingPipelineCreateInfoNV, p_groups), offset_of!(RayTracingPipelineCreateInfoNV, max_recursion_depth), offset_of!(RayTracingPipelineCreateInfoNV, layout), offset_of!(RayTracingPipelineCreateInfoNV, base_pipeline_handle), offset_of!(RayTracingPipelineCreateInfoNV, base_pipeline_index));
    println!("RayTracingPipelineCreateInfoKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<RayTracingPipelineCreateInfoKHR>(), align_of::<RayTracingPipelineCreateInfoKHR>(), offset_of!(RayTracingPipelineCreateInfoKHR, s_type), offset_of!(RayTracingPipelineCreateInfoKHR, p_next), offset_of!(RayTracingPipelineCreateInfoKHR, flags), offset_of!(RayTracingPipelineCreateInfoKHR, stage_count), offset_of!(RayTracingPipelineCreateInfoKHR, p_stages), offset_of!(RayTracingPipelineCreateInfoKHR, group_count), offset_of!(RayTracingPipelineCreateInfoKHR, p_groups), offset_of!(RayTracingPipelineCreateInfoKHR, max_pipeline_ray_recursion_depth), offset_of!(RayTracingPipelineCreateInfoKHR, p_library_info), offset_of!(RayTracingPipelineCreateInfoKHR, p_library_interface), offset_of!(RayTracingPipelineCreateInfoKHR, p_dynamic_state), offset_of!(RayTracingPipelineCreateInfoKHR, layout), offset_of!(RayTracingPipelineCreateInfoKHR, base_pipeline_handle), offset_of!(RayTracingPipelineCreateInfoKHR, base_pipeline_index));
    println!("GeometryTrianglesNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<GeometryTrianglesNV>(), align_of::<GeometryTrianglesNV>(), offset_of!(GeometryTrianglesNV, s_type), offset_of!(GeometryTrianglesNV, p_next), offset_of!(GeometryTrianglesNV, vertex_data), offset_of!(GeometryTrianglesNV, vertex_offset), offset_of!(GeometryTrianglesNV, vertex_count), offset_of!(GeometryTrianglesNV, vertex_stride), offset_of!(GeometryTrianglesNV, vertex_format), offset_of!(GeometryTrianglesNV, index_data), offset_of!(GeometryTrianglesNV, index_offset), offset_of!(GeometryTrianglesNV, index_count), offset_of!(GeometryTrianglesNV, index_type), offset_of!(GeometryTrianglesNV, transform_data), offset_of!(GeometryTrianglesNV, transform_offset));
    println!("GeometryAABBNV {} {} {} {} {} {} {} {}", size_of::<GeometryAABBNV>(), align_of::<GeometryAABBNV>(), offset_of!(GeometryAABBNV, s_type), offset_of!(GeometryAABBNV, p_next), offset_of!(GeometryAABBNV, aabb_data), offset_of!(GeometryAABBNV, num_aab_bs), offset_of!(GeometryAABBNV, stride), offset_of!(GeometryAABBNV, offset));
    println!("GeometryDataNV {} {} {} {}", size_of::<GeometryDataNV>(), align_of::<GeometryDataNV>(), offset_of!(GeometryDataNV, triangles), offset_of!(GeometryDataNV, aabbs));
    println!("GeometryNV {} {} {} {} {} {} {}", size_of::<GeometryNV>(), align_of::<GeometryNV>(), offset_of!(GeometryNV, s_type), offset_of!(GeometryNV, p_next), offset_of!(GeometryNV, geometry_type), offset_of!(GeometryNV, geometry), offset_of!(GeometryNV, flags));
    println!("AccelerationStructureInfoNV {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureInfoNV>(), align_of::<AccelerationStructureInfoNV>(), offset_of!(AccelerationStructureInfoNV, s_type), offset_of!(AccelerationStructureInfoNV, p_next), offset_of!(AccelerationStructureInfoNV, flags), offset_of!(AccelerationStructureInfoNV, instance_count), offset_of!(AccelerationStructureInfoNV, geometry_count), offset_of!(AccelerationStructureInfoNV, p_geometries));
    println!("AccelerationStructureCreateInfoNV {} {} {} {} {} {}", size_of::<AccelerationStructureCreateInfoNV>(), align_of::<AccelerationStructureCreateInfoNV>(), offset_of!(AccelerationStructureCreateInfoNV, s_type), offset_of!(AccelerationStructureCreateInfoNV, p_next), offset_of!(AccelerationStructureCreateInfoNV, compacted_size), offset_of!(AccelerationStructureCreateInfoNV, info));
    println!("BindAccelerationStructureMemoryInfoNV {} {} {} {} {} {} {} {} {}", size_of::<BindAccelerationStructureMemoryInfoNV>(), align_of::<BindAccelerationStructureMemoryInfoNV>(), offset_of!(BindAccelerationStructureMemoryInfoNV, s_type), offset_of!(BindAccelerationStructureMemoryInfoNV, p_next), offset_of!(BindAccelerationStructureMemoryInfoNV, acceleration_structure), offset_of!(BindAccelerationStructureMemoryInfoNV, memory), offset_of!(BindAccelerationStructureMemoryInfoNV, memory_offset), offset_of!(BindAccelerationStructureMemoryInfoNV, device_index_count), offset_of!(BindAccelerationStructureMemoryInfoNV, p_device_indices));
    println!("WriteDescriptorSetAccelerationStructureKHR {} {} {} {} {} {}", size_of::<WriteDescriptorSetAccelerationStructureKHR>(), align_of::<WriteDescriptorSetAccelerationStructureKHR>(), offset_of!(WriteDescriptorSetAccelerationStructureKHR, s_type), offset_of!(WriteDescriptorSetAccelerationStructureKHR, p_next), offset_of!(WriteDescriptorSetAccelerationStructureKHR, acceleration_structure_count), offset_of!(WriteDescriptorSetAccelerationStructureKHR, p_acceleration_structures));
    println!("WriteDescriptorSetAccelerationStructureNV {} {} {} {} {} {}", size_of::<WriteDescriptorSetAccelerationStructureNV>(), align_of::<WriteDescriptorSetAccelerationStructureNV>(), offset_of!(WriteDescriptorSetAccelerationStructureNV, s_type), offset_of!(WriteDescriptorSetAccelerationStructureNV, p_next), offset_of!(WriteDescriptorSetAccelerationStructureNV, acceleration_structure_count), offset_of!(WriteDescriptorSetAccelerationStructureNV, p_acceleration_structures));
    println!("AccelerationStructureMemoryRequirementsInfoNV {} {} {} {} {}", size_of::<AccelerationStructureMemoryRequirementsInfoNV>(), align_of::<AccelerationStructureMemoryRequirementsInfoNV>(), offset_of!(AccelerationStructureMemoryRequirementsInfoNV, s_type), offset_of!(AccelerationStructureMemoryRequirementsInfoNV, p_next), offset_of!(AccelerationStructureMemoryRequirementsInfoNV, acceleration_structure));
    println!("PhysicalDeviceAccelerationStructureFeaturesKHR {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceAccelerationStructureFeaturesKHR>(), align_of::<PhysicalDeviceAccelerationStructureFeaturesKHR>(), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, s_type), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, p_next), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, acceleration_structure), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, acceleration_structure_capture_replay), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, acceleration_structure_indirect_build), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, acceleration_structure_host_commands), offset_of!(PhysicalDeviceAccelerationStructureFeaturesKHR, descriptor_binding_acceleration_structure_update_after_bind));
    println!("PhysicalDeviceRayTracingPipelineFeaturesKHR {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingPipelineFeaturesKHR>(), align_of::<PhysicalDeviceRayTracingPipelineFeaturesKHR>(), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, s_type), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, p_next), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, ray_tracing_pipeline), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, ray_tracing_pipeline_shader_group_handle_capture_replay), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, ray_tracing_pipeline_shader_group_handle_capture_replay_mixed), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, ray_tracing_pipeline_trace_rays_indirect), offset_of!(PhysicalDeviceRayTracingPipelineFeaturesKHR, ray_traversal_primitive_culling));
    println!("PhysicalDeviceRayQueryFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceRayQueryFeaturesKHR>(), align_of::<PhysicalDeviceRayQueryFeaturesKHR>(), offset_of!(PhysicalDeviceRayQueryFeaturesKHR, s_type), offset_of!(PhysicalDeviceRayQueryFeaturesKHR, p_next), offset_of!(PhysicalDeviceRayQueryFeaturesKHR, ray_query));
    println!("PhysicalDeviceAccelerationStructurePropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceAccelerationStructurePropertiesKHR>(), align_of::<PhysicalDeviceAccelerationStructurePropertiesKHR>(), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, s_type), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, p_next), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_geometry_count), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_instance_count), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_primitive_count), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_per_stage_descriptor_acceleration_structures), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_per_stage_descriptor_update_after_bind_acceleration_structures), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_descriptor_set_acceleration_structures), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, max_descriptor_set_update_after_bind_acceleration_structures), offset_of!(PhysicalDeviceAccelerationStructurePropertiesKHR, min_acceleration_structure_scratch_offset_alignment));
    println!("PhysicalDeviceRayTracingPipelinePropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingPipelinePropertiesKHR>(), align_of::<PhysicalDeviceRayTracingPipelinePropertiesKHR>(), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, s_type), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, p_next), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, shader_group_handle_size), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, max_ray_recursion_depth), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, max_shader_group_stride), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, shader_group_base_alignment), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, shader_group_handle_capture_replay_size), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, max_ray_dispatch_invocation_count), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, shader_group_handle_alignment), offset_of!(PhysicalDeviceRayTracingPipelinePropertiesKHR, max_ray_hit_attribute_size));
    println!("PhysicalDeviceRayTracingPropertiesNV {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingPropertiesNV>(), align_of::<PhysicalDeviceRayTracingPropertiesNV>(), offset_of!(PhysicalDeviceRayTracingPropertiesNV, s_type), offset_of!(PhysicalDeviceRayTracingPropertiesNV, p_next), offset_of!(PhysicalDeviceRayTracingPropertiesNV, shader_group_handle_size), offset_of!(PhysicalDeviceRayTracingPropertiesNV, max_recursion_depth), offset_of!(PhysicalDeviceRayTracingPropertiesNV, max_shader_group_stride), offset_of!(PhysicalDeviceRayTracingPropertiesNV, shader_group_base_alignment), offset_of!(PhysicalDeviceRayTracingPropertiesNV, max_geometry_count), offset_of!(PhysicalDeviceRayTracingPropertiesNV, max_instance_count), offset_of!(PhysicalDeviceRayTracingPropertiesNV, max_triangle_count), offset_of!(PhysicalDeviceRayTracingPropertiesNV, max_descriptor_set_acceleration_structures));
    println!("StridedDeviceAddressRegionKHR {} {} {} {} {}", size_of::<StridedDeviceAddressRegionKHR>(), align_of::<StridedDeviceAddressRegionKHR>(), offset_of!(StridedDeviceAddressRegionKHR, device_address), offset_of!(StridedDeviceAddressRegionKHR, stride), offset_of!(StridedDeviceAddressRegionKHR, size));
    println!("TraceRaysIndirectCommandKHR {} {} {} {} {}", size_of::<TraceRaysIndirectCommandKHR>(), align_of::<TraceRaysIndirectCommandKHR>(), offset_of!(TraceRaysIndirectCommandKHR, width), offset_of!(TraceRaysIndirectCommandKHR, height), offset_of!(TraceRaysIndirectCommandKHR, depth));
    println!("TraceRaysIndirectCommand2KHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<TraceRaysIndirectCommand2KHR>(), align_of::<TraceRaysIndirectCommand2KHR>(), offset_of!(TraceRaysIndirectCommand2KHR, raygen_shader_record_address), offset_of!(TraceRaysIndirectCommand2KHR, raygen_shader_record_size), offset_of!(TraceRaysIndirectCommand2KHR, miss_shader_binding_table_address), offset_of!(TraceRaysIndirectCommand2KHR, miss_shader_binding_table_size), offset_of!(TraceRaysIndirectCommand2KHR, miss_shader_binding_table_stride), offset_of!(TraceRaysIndirectCommand2KHR, hit_shader_binding_table_address), offset_of!(TraceRaysIndirectCommand2KHR, hit_shader_binding_table_size), offset_of!(TraceRaysIndirectCommand2KHR, hit_shader_binding_table_stride), offset_of!(TraceRaysIndirectCommand2KHR, callable_shader_binding_table_address), offset_of!(TraceRaysIndirectCommand2KHR, callable_shader_binding_table_size), offset_of!(TraceRaysIndirectCommand2KHR, callable_shader_binding_table_stride), offset_of!(TraceRaysIndirectCommand2KHR, width), offset_of!(TraceRaysIndirectCommand2KHR, height), offset_of!(TraceRaysIndirectCommand2KHR, depth));
    println!("PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingMaintenance1FeaturesKHR>(), align_of::<PhysicalDeviceRayTracingMaintenance1FeaturesKHR>(), offset_of!(PhysicalDeviceRayTracingMaintenance1FeaturesKHR, s_type), offset_of!(PhysicalDeviceRayTracingMaintenance1FeaturesKHR, p_next), offset_of!(PhysicalDeviceRayTracingMaintenance1FeaturesKHR, ray_tracing_maintenance1), offset_of!(PhysicalDeviceRayTracingMaintenance1FeaturesKHR, ray_tracing_pipeline_trace_rays_indirect2));
    println!("DrmFormatModifierPropertiesListEXT {} {} {} {} {} {}", size_of::<DrmFormatModifierPropertiesListEXT>(), align_of::<DrmFormatModifierPropertiesListEXT>(), offset_of!(DrmFormatModifierPropertiesListEXT, s_type), offset_of!(DrmFormatModifierPropertiesListEXT, p_next), offset_of!(DrmFormatModifierPropertiesListEXT, drm_format_modifier_count), offset_of!(DrmFormatModifierPropertiesListEXT, p_drm_format_modifier_properties));
    println!("DrmFormatModifierPropertiesEXT {} {} {} {} {}", size_of::<DrmFormatModifierPropertiesEXT>(), align_of::<DrmFormatModifierPropertiesEXT>(), offset_of!(DrmFormatModifierPropertiesEXT, drm_format_modifier), offset_of!(DrmFormatModifierPropertiesEXT, drm_format_modifier_plane_count), offset_of!(DrmFormatModifierPropertiesEXT, drm_format_modifier_tiling_features));
    println!("PhysicalDeviceImageDrmFormatModifierInfoEXT {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceImageDrmFormatModifierInfoEXT>(), align_of::<PhysicalDeviceImageDrmFormatModifierInfoEXT>(), offset_of!(PhysicalDeviceImageDrmFormatModifierInfoEXT, s_type), offset_of!(PhysicalDeviceImageDrmFormatModifierInfoEXT, p_next), offset_of!(PhysicalDeviceImageDrmFormatModifierInfoEXT, drm_format_modifier), offset_of!(PhysicalDeviceImageDrmFormatModifierInfoEXT, sharing_mode), offset_of!(PhysicalDeviceImageDrmFormatModifierInfoEXT, queue_family_index_count), offset_of!(PhysicalDeviceImageDrmFormatModifierInfoEXT, p_queue_family_indices));
    println!("ImageDrmFormatModifierListCreateInfoEXT {} {} {} {} {} {}", size_of::<ImageDrmFormatModifierListCreateInfoEXT>(), align_of::<ImageDrmFormatModifierListCreateInfoEXT>(), offset_of!(ImageDrmFormatModifierListCreateInfoEXT, s_type), offset_of!(ImageDrmFormatModifierListCreateInfoEXT, p_next), offset_of!(ImageDrmFormatModifierListCreateInfoEXT, drm_format_modifier_count), offset_of!(ImageDrmFormatModifierListCreateInfoEXT, p_drm_format_modifiers));
    println!("ImageDrmFormatModifierExplicitCreateInfoEXT {} {} {} {} {} {} {}", size_of::<ImageDrmFormatModifierExplicitCreateInfoEXT>(), align_of::<ImageDrmFormatModifierExplicitCreateInfoEXT>(), offset_of!(ImageDrmFormatModifierExplicitCreateInfoEXT, s_type), offset_of!(ImageDrmFormatModifierExplicitCreateInfoEXT, p_next), offset_of!(ImageDrmFormatModifierExplicitCreateInfoEXT, drm_format_modifier), offset_of!(ImageDrmFormatModifierExplicitCreateInfoEXT, drm_format_modifier_plane_count), offset_of!(ImageDrmFormatModifierExplicitCreateInfoEXT, p_plane_layouts));
    println!("ImageDrmFormatModifierPropertiesEXT {} {} {} {} {}", size_of::<ImageDrmFormatModifierPropertiesEXT>(), align_of::<ImageDrmFormatModifierPropertiesEXT>(), offset_of!(ImageDrmFormatModifierPropertiesEXT, s_type), offset_of!(ImageDrmFormatModifierPropertiesEXT, p_next), offset_of!(ImageDrmFormatModifierPropertiesEXT, drm_format_modifier));
    println!("ImageStencilUsageCreateInfo {} {} {} {} {}", size_of::<ImageStencilUsageCreateInfo>(), align_of::<ImageStencilUsageCreateInfo>(), offset_of!(ImageStencilUsageCreateInfo, s_type), offset_of!(ImageStencilUsageCreateInfo, p_next), offset_of!(ImageStencilUsageCreateInfo, stencil_usage));
    println!("DeviceMemoryOverallocationCreateInfoAMD {} {} {} {} {}", size_of::<DeviceMemoryOverallocationCreateInfoAMD>(), align_of::<DeviceMemoryOverallocationCreateInfoAMD>(), offset_of!(DeviceMemoryOverallocationCreateInfoAMD, s_type), offset_of!(DeviceMemoryOverallocationCreateInfoAMD, p_next), offset_of!(DeviceMemoryOverallocationCreateInfoAMD, overallocation_behavior));
    println!("PhysicalDeviceFragmentDensityMapFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMapFeaturesEXT>(), align_of::<PhysicalDeviceFragmentDensityMapFeaturesEXT>(), offset_of!(PhysicalDeviceFragmentDensityMapFeaturesEXT, s_type), offset_of!(PhysicalDeviceFragmentDensityMapFeaturesEXT, p_next), offset_of!(PhysicalDeviceFragmentDensityMapFeaturesEXT, fragment_density_map), offset_of!(PhysicalDeviceFragmentDensityMapFeaturesEXT, fragment_density_map_dynamic), offset_of!(PhysicalDeviceFragmentDensityMapFeaturesEXT, fragment_density_map_non_subsampled_images));
    println!("PhysicalDeviceFragmentDensityMap2FeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMap2FeaturesEXT>(), align_of::<PhysicalDeviceFragmentDensityMap2FeaturesEXT>(), offset_of!(PhysicalDeviceFragmentDensityMap2FeaturesEXT, s_type), offset_of!(PhysicalDeviceFragmentDensityMap2FeaturesEXT, p_next), offset_of!(PhysicalDeviceFragmentDensityMap2FeaturesEXT, fragment_density_map_deferred));
    println!("PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>(), align_of::<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>(), offset_of!(PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, s_type), offset_of!(PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, p_next), offset_of!(PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, fragment_density_map_offset));
    println!("PhysicalDeviceFragmentDensityMapPropertiesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMapPropertiesEXT>(), align_of::<PhysicalDeviceFragmentDensityMapPropertiesEXT>(), offset_of!(PhysicalDeviceFragmentDensityMapPropertiesEXT, s_type), offset_of!(PhysicalDeviceFragmentDensityMapPropertiesEXT, p_next), offset_of!(PhysicalDeviceFragmentDensityMapPropertiesEXT, min_fragment_density_texel_size), offset_of!(PhysicalDeviceFragmentDensityMapPropertiesEXT, max_fragment_density_texel_size), offset_of!(PhysicalDeviceFragmentDensityMapPropertiesEXT, fragment_density_invocations));
    println!("PhysicalDeviceFragmentDensityMap2PropertiesEXT {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMap2PropertiesEXT>(), align_of::<PhysicalDeviceFragmentDensityMap2PropertiesEXT>(), offset_of!(PhysicalDeviceFragmentDensityMap2PropertiesEXT, s_type), offset_of!(PhysicalDeviceFragmentDensityMap2PropertiesEXT, p_next), offset_of!(PhysicalDeviceFragmentDensityMap2PropertiesEXT, subsampled_loads), offset_of!(PhysicalDeviceFragmentDensityMap2PropertiesEXT, subsampled_coarse_reconstruction_early_access), offset_of!(PhysicalDeviceFragmentDensityMap2PropertiesEXT, max_subsampled_array_layers), offset_of!(PhysicalDeviceFragmentDensityMap2PropertiesEXT, max_descriptor_set_subsampled_samplers));
    println!("PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>(), align_of::<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>(), offset_of!(PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, s_type), offset_of!(PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, p_next), offset_of!(PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, fragment_density_offset_granularity));
    println!("RenderPassFragmentDensityMapCreateInfoEXT {} {} {} {} {}", size_of::<RenderPassFragmentDensityMapCreateInfoEXT>(), align_of::<RenderPassFragmentDensityMapCreateInfoEXT>(), offset_of!(RenderPassFragmentDensityMapCreateInfoEXT, s_type), offset_of!(RenderPassFragmentDensityMapCreateInfoEXT, p_next), offset_of!(RenderPassFragmentDensityMapCreateInfoEXT, fragment_density_map_attachment));
    println!("RenderPassFragmentDensityMapOffsetEndInfoEXT {} {} {} {} {} {}", size_of::<RenderPassFragmentDensityMapOffsetEndInfoEXT>(), align_of::<RenderPassFragmentDensityMapOffsetEndInfoEXT>(), offset_of!(RenderPassFragmentDensityMapOffsetEndInfoEXT, s_type), offset_of!(RenderPassFragmentDensityMapOffsetEndInfoEXT, p_next), offset_of!(RenderPassFragmentDensityMapOffsetEndInfoEXT, fragment_density_offset_count), offset_of!(RenderPassFragmentDensityMapOffsetEndInfoEXT, p_fragment_density_offsets));
    println!("PhysicalDeviceScalarBlockLayoutFeatures {} {} {} {} {}", size_of::<PhysicalDeviceScalarBlockLayoutFeatures>(), align_of::<PhysicalDeviceScalarBlockLayoutFeatures>(), offset_of!(PhysicalDeviceScalarBlockLayoutFeatures, s_type), offset_of!(PhysicalDeviceScalarBlockLayoutFeatures, p_next), offset_of!(PhysicalDeviceScalarBlockLayoutFeatures, scalar_block_layout));
    println!("SurfaceProtectedCapabilitiesKHR {} {} {} {} {}", size_of::<SurfaceProtectedCapabilitiesKHR>(), align_of::<SurfaceProtectedCapabilitiesKHR>(), offset_of!(SurfaceProtectedCapabilitiesKHR, s_type), offset_of!(SurfaceProtectedCapabilitiesKHR, p_next), offset_of!(SurfaceProtectedCapabilitiesKHR, supports_protected));
    println!("PhysicalDeviceUniformBufferStandardLayoutFeatures {} {} {} {} {}", size_of::<PhysicalDeviceUniformBufferStandardLayoutFeatures>(), align_of::<PhysicalDeviceUniformBufferStandardLayoutFeatures>(), offset_of!(PhysicalDeviceUniformBufferStandardLayoutFeatures, s_type), offset_of!(PhysicalDeviceUniformBufferStandardLayoutFeatures, p_next), offset_of!(PhysicalDeviceUniformBufferStandardLayoutFeatures, uniform_buffer_standard_layout));
    println!("PhysicalDeviceDepthClipEnableFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDepthClipEnableFeaturesEXT>(), align_of::<PhysicalDeviceDepthClipEnableFeaturesEXT>(), offset_of!(PhysicalDeviceDepthClipEnableFeaturesEXT, s_type), offset_of!(PhysicalDeviceDepthClipEnableFeaturesEXT, p_next), offset_of!(PhysicalDeviceDepthClipEnableFeaturesEXT, depth_clip_enable));
    println!("PipelineRasterizationDepthClipStateCreateInfoEXT {} {} {} {} {} {}", size_of::<PipelineRasterizationDepthClipStateCreateInfoEXT>(), align_of::<PipelineRasterizationDepthClipStateCreateInfoEXT>(), offset_of!(PipelineRasterizationDepthClipStateCreateInfoEXT, s_type), offset_of!(PipelineRasterizationDepthClipStateCreateInfoEXT, p_next), offset_of!(PipelineRasterizationDepthClipStateCreateInfoEXT, flags), offset_of!(PipelineRasterizationDepthClipStateCreateInfoEXT, depth_clip_enable));
    println!("PhysicalDeviceMemoryBudgetPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceMemoryBudgetPropertiesEXT>(), align_of::<PhysicalDeviceMemoryBudgetPropertiesEXT>(), offset_of!(PhysicalDeviceMemoryBudgetPropertiesEXT, s_type), offset_of!(PhysicalDeviceMemoryBudgetPropertiesEXT, p_next), offset_of!(PhysicalDeviceMemoryBudgetPropertiesEXT, heap_budget), offset_of!(PhysicalDeviceMemoryBudgetPropertiesEXT, heap_usage));
    println!("PhysicalDeviceMemoryPriorityFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMemoryPriorityFeaturesEXT>(), align_of::<PhysicalDeviceMemoryPriorityFeaturesEXT>(), offset_of!(PhysicalDeviceMemoryPriorityFeaturesEXT, s_type), offset_of!(PhysicalDeviceMemoryPriorityFeaturesEXT, p_next), offset_of!(PhysicalDeviceMemoryPriorityFeaturesEXT, memory_priority));
    println!("MemoryPriorityAllocateInfoEXT {} {} {} {} {}", size_of::<MemoryPriorityAllocateInfoEXT>(), align_of::<MemoryPriorityAllocateInfoEXT>(), offset_of!(MemoryPriorityAllocateInfoEXT, s_type), offset_of!(MemoryPriorityAllocateInfoEXT, p_next), offset_of!(MemoryPriorityAllocateInfoEXT, priority));
    println!("PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(), align_of::<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(), offset_of!(PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, s_type), offset_of!(PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, p_next), offset_of!(PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, pageable_device_local_memory));
    println!("PhysicalDeviceBufferDeviceAddressFeatures {} {} {} {} {} {} {}", size_of::<PhysicalDeviceBufferDeviceAddressFeatures>(), align_of::<PhysicalDeviceBufferDeviceAddressFeatures>(), offset_of!(PhysicalDeviceBufferDeviceAddressFeatures, s_type), offset_of!(PhysicalDeviceBufferDeviceAddressFeatures, p_next), offset_of!(PhysicalDeviceBufferDeviceAddressFeatures, buffer_device_address), offset_of!(PhysicalDeviceBufferDeviceAddressFeatures, buffer_device_address_capture_replay), offset_of!(PhysicalDeviceBufferDeviceAddressFeatures, buffer_device_address_multi_device));
    println!("PhysicalDeviceBufferDeviceAddressFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceBufferDeviceAddressFeaturesEXT>(), align_of::<PhysicalDeviceBufferDeviceAddressFeaturesEXT>(), offset_of!(PhysicalDeviceBufferDeviceAddressFeaturesEXT, s_type), offset_of!(PhysicalDeviceBufferDeviceAddressFeaturesEXT, p_next), offset_of!(PhysicalDeviceBufferDeviceAddressFeaturesEXT, buffer_device_address), offset_of!(PhysicalDeviceBufferDeviceAddressFeaturesEXT, buffer_device_address_capture_replay), offset_of!(PhysicalDeviceBufferDeviceAddressFeaturesEXT, buffer_device_address_multi_device));
    println!("BufferDeviceAddressInfo {} {} {} {} {}", size_of::<BufferDeviceAddressInfo>(), align_of::<BufferDeviceAddressInfo>(), offset_of!(BufferDeviceAddressInfo, s_type), offset_of!(BufferDeviceAddressInfo, p_next), offset_of!(BufferDeviceAddressInfo, buffer));
    println!("BufferOpaqueCaptureAddressCreateInfo {} {} {} {} {}", size_of::<BufferOpaqueCaptureAddressCreateInfo>(), align_of::<BufferOpaqueCaptureAddressCreateInfo>(), offset_of!(BufferOpaqueCaptureAddressCreateInfo, s_type), offset_of!(BufferOpaqueCaptureAddressCreateInfo, p_next), offset_of!(BufferOpaqueCaptureAddressCreateInfo, opaque_capture_address));
    println!("BufferDeviceAddressCreateInfoEXT {} {} {} {} {}", size_of::<BufferDeviceAddressCreateInfoEXT>(), align_of::<BufferDeviceAddressCreateInfoEXT>(), offset_of!(BufferDeviceAddressCreateInfoEXT, s_type), offset_of!(BufferDeviceAddressCreateInfoEXT, p_next), offset_of!(BufferDeviceAddressCreateInfoEXT, device_address));
    println!("PhysicalDeviceImageViewImageFormatInfoEXT {} {} {} {} {}", size_of::<PhysicalDeviceImageViewImageFormatInfoEXT>(), align_of::<PhysicalDeviceImageViewImageFormatInfoEXT>(), offset_of!(PhysicalDeviceImageViewImageFormatInfoEXT, s_type), offset_of!(PhysicalDeviceImageViewImageFormatInfoEXT, p_next), offset_of!(PhysicalDeviceImageViewImageFormatInfoEXT, image_view_type));
    println!("FilterCubicImageViewImageFormatPropertiesEXT {} {} {} {} {} {}", size_of::<FilterCubicImageViewImageFormatPropertiesEXT>(), align_of::<FilterCubicImageViewImageFormatPropertiesEXT>(), offset_of!(FilterCubicImageViewImageFormatPropertiesEXT, s_type), offset_of!(FilterCubicImageViewImageFormatPropertiesEXT, p_next), offset_of!(FilterCubicImageViewImageFormatPropertiesEXT, filter_cubic), offset_of!(FilterCubicImageViewImageFormatPropertiesEXT, filter_cubic_minmax));
    println!("PhysicalDeviceImagelessFramebufferFeatures {} {} {} {} {}", size_of::<PhysicalDeviceImagelessFramebufferFeatures>(), align_of::<PhysicalDeviceImagelessFramebufferFeatures>(), offset_of!(PhysicalDeviceImagelessFramebufferFeatures, s_type), offset_of!(PhysicalDeviceImagelessFramebufferFeatures, p_next), offset_of!(PhysicalDeviceImagelessFramebufferFeatures, imageless_framebuffer));
    println!("FramebufferAttachmentsCreateInfo {} {} {} {} {} {}", size_of::<FramebufferAttachmentsCreateInfo>(), align_of::<FramebufferAttachmentsCreateInfo>(), offset_of!(FramebufferAttachmentsCreateInfo, s_type), offset_of!(FramebufferAttachmentsCreateInfo, p_next), offset_of!(FramebufferAttachmentsCreateInfo, attachment_image_info_count), offset_of!(FramebufferAttachmentsCreateInfo, p_attachment_image_infos));
    println!("FramebufferAttachmentImageInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<FramebufferAttachmentImageInfo>(), align_of::<FramebufferAttachmentImageInfo>(), offset_of!(FramebufferAttachmentImageInfo, s_type), offset_of!(FramebufferAttachmentImageInfo, p_next), offset_of!(FramebufferAttachmentImageInfo, flags), offset_of!(FramebufferAttachmentImageInfo, usage), offset_of!(FramebufferAttachmentImageInfo, width), offset_of!(FramebufferAttachmentImageInfo, height), offset_of!(FramebufferAttachmentImageInfo, layer_count), offset_of!(FramebufferAttachmentImageInfo, view_format_count), offset_of!(FramebufferAttachmentImageInfo, p_view_formats));
    println!("RenderPassAttachmentBeginInfo {} {} {} {} {} {}", size_of::<RenderPassAttachmentBeginInfo>(), align_of::<RenderPassAttachmentBeginInfo>(), offset_of!(RenderPassAttachmentBeginInfo, s_type), offset_of!(RenderPassAttachmentBeginInfo, p_next), offset_of!(RenderPassAttachmentBeginInfo, attachment_count), offset_of!(RenderPassAttachmentBeginInfo, p_attachments));
    println!("PhysicalDeviceTextureCompressionASTCHDRFeatures {} {} {} {} {}", size_of::<PhysicalDeviceTextureCompressionASTCHDRFeatures>(), align_of::<PhysicalDeviceTextureCompressionASTCHDRFeatures>(), offset_of!(PhysicalDeviceTextureCompressionASTCHDRFeatures, s_type), offset_of!(PhysicalDeviceTextureCompressionASTCHDRFeatures, p_next), offset_of!(PhysicalDeviceTextureCompressionASTCHDRFeatures, texture_compression_astc_hdr));
    println!("PhysicalDeviceCooperativeMatrixFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrixFeaturesNV>(), align_of::<PhysicalDeviceCooperativeMatrixFeaturesNV>(), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesNV, s_type), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesNV, p_next), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesNV, cooperative_matrix), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesNV, cooperative_matrix_robust_buffer_access));
    println!("PhysicalDeviceCooperativeMatrixPropertiesNV {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrixPropertiesNV>(), align_of::<PhysicalDeviceCooperativeMatrixPropertiesNV>(), offset_of!(PhysicalDeviceCooperativeMatrixPropertiesNV, s_type), offset_of!(PhysicalDeviceCooperativeMatrixPropertiesNV, p_next), offset_of!(PhysicalDeviceCooperativeMatrixPropertiesNV, cooperative_matrix_supported_stages));
    println!("CooperativeMatrixPropertiesNV {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<CooperativeMatrixPropertiesNV>(), align_of::<CooperativeMatrixPropertiesNV>(), offset_of!(CooperativeMatrixPropertiesNV, s_type), offset_of!(CooperativeMatrixPropertiesNV, p_next), offset_of!(CooperativeMatrixPropertiesNV, m_size), offset_of!(CooperativeMatrixPropertiesNV, n_size), offset_of!(CooperativeMatrixPropertiesNV, k_size), offset_of!(CooperativeMatrixPropertiesNV, a_type), offset_of!(CooperativeMatrixPropertiesNV, b_type), offset_of!(CooperativeMatrixPropertiesNV, c_type), offset_of!(CooperativeMatrixPropertiesNV, d_type), offset_of!(CooperativeMatrixPropertiesNV, scope));
    println!("PhysicalDeviceYcbcrImageArraysFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceYcbcrImageArraysFeaturesEXT>(), align_of::<PhysicalDeviceYcbcrImageArraysFeaturesEXT>(), offset_of!(PhysicalDeviceYcbcrImageArraysFeaturesEXT, s_type), offset_of!(PhysicalDeviceYcbcrImageArraysFeaturesEXT, p_next), offset_of!(PhysicalDeviceYcbcrImageArraysFeaturesEXT, ycbcr_image_arrays));
    println!("ImageViewHandleInfoNVX {} {} {} {} {} {} {}", size_of::<ImageViewHandleInfoNVX>(), align_of::<ImageViewHandleInfoNVX>(), offset_of!(ImageViewHandleInfoNVX, s_type), offset_of!(ImageViewHandleInfoNVX, p_next), offset_of!(ImageViewHandleInfoNVX, image_view), offset_of!(ImageViewHandleInfoNVX, descriptor_type), offset_of!(ImageViewHandleInfoNVX, sampler));
    println!("ImageViewAddressPropertiesNVX {} {} {} {} {} {}", size_of::<ImageViewAddressPropertiesNVX>(), align_of::<ImageViewAddressPropertiesNVX>(), offset_of!(ImageViewAddressPropertiesNVX, s_type), offset_of!(ImageViewAddressPropertiesNVX, p_next), offset_of!(ImageViewAddressPropertiesNVX, device_address), offset_of!(ImageViewAddressPropertiesNVX, size));
    println!("PipelineCreationFeedback {} {} {} {}", size_of::<PipelineCreationFeedback>(), align_of::<PipelineCreationFeedback>(), offset_of!(PipelineCreationFeedback, flags), offset_of!(PipelineCreationFeedback, duration));
    println!("PipelineCreationFeedbackCreateInfo {} {} {} {} {} {} {}", size_of::<PipelineCreationFeedbackCreateInfo>(), align_of::<PipelineCreationFeedbackCreateInfo>(), offset_of!(PipelineCreationFeedbackCreateInfo, s_type), offset_of!(PipelineCreationFeedbackCreateInfo, p_next), offset_of!(PipelineCreationFeedbackCreateInfo, p_pipeline_creation_feedback), offset_of!(PipelineCreationFeedbackCreateInfo, pipeline_stage_creation_feedback_count), offset_of!(PipelineCreationFeedbackCreateInfo, p_pipeline_stage_creation_feedbacks));
    println!("PhysicalDevicePresentBarrierFeaturesNV {} {} {} {} {}", size_of::<PhysicalDevicePresentBarrierFeaturesNV>(), align_of::<PhysicalDevicePresentBarrierFeaturesNV>(), offset_of!(PhysicalDevicePresentBarrierFeaturesNV, s_type), offset_of!(PhysicalDevicePresentBarrierFeaturesNV, p_next), offset_of!(PhysicalDevicePresentBarrierFeaturesNV, present_barrier));
    println!("SurfaceCapabilitiesPresentBarrierNV {} {} {} {} {}", size_of::<SurfaceCapabilitiesPresentBarrierNV>(), align_of::<SurfaceCapabilitiesPresentBarrierNV>(), offset_of!(SurfaceCapabilitiesPresentBarrierNV, s_type), offset_of!(SurfaceCapabilitiesPresentBarrierNV, p_next), offset_of!(SurfaceCapabilitiesPresentBarrierNV, present_barrier_supported));
    println!("SwapchainPresentBarrierCreateInfoNV {} {} {} {} {}", size_of::<SwapchainPresentBarrierCreateInfoNV>(), align_of::<SwapchainPresentBarrierCreateInfoNV>(), offset_of!(SwapchainPresentBarrierCreateInfoNV, s_type), offset_of!(SwapchainPresentBarrierCreateInfoNV, p_next), offset_of!(SwapchainPresentBarrierCreateInfoNV, present_barrier_enable));
    println!("PhysicalDevicePerformanceQueryFeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDevicePerformanceQueryFeaturesKHR>(), align_of::<PhysicalDevicePerformanceQueryFeaturesKHR>(), offset_of!(PhysicalDevicePerformanceQueryFeaturesKHR, s_type), offset_of!(PhysicalDevicePerformanceQueryFeaturesKHR, p_next), offset_of!(PhysicalDevicePerformanceQueryFeaturesKHR, performance_counter_query_pools), offset_of!(PhysicalDevicePerformanceQueryFeaturesKHR, performance_counter_multiple_query_pools));
    println!("PhysicalDevicePerformanceQueryPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDevicePerformanceQueryPropertiesKHR>(), align_of::<PhysicalDevicePerformanceQueryPropertiesKHR>(), offset_of!(PhysicalDevicePerformanceQueryPropertiesKHR, s_type), offset_of!(PhysicalDevicePerformanceQueryPropertiesKHR, p_next), offset_of!(PhysicalDevicePerformanceQueryPropertiesKHR, allow_command_buffer_query_copies));
    println!("PerformanceCounterKHR {} {} {} {} {} {} {} {}", size_of::<PerformanceCounterKHR>(), align_of::<PerformanceCounterKHR>(), offset_of!(PerformanceCounterKHR, s_type), offset_of!(PerformanceCounterKHR, p_next), offset_of!(PerformanceCounterKHR, unit), offset_of!(PerformanceCounterKHR, scope), offset_of!(PerformanceCounterKHR, storage), offset_of!(PerformanceCounterKHR, uuid));
    println!("PerformanceCounterDescriptionKHR {} {} {} {} {} {} {} {}", size_of::<PerformanceCounterDescriptionKHR>(), align_of::<PerformanceCounterDescriptionKHR>(), offset_of!(PerformanceCounterDescriptionKHR, s_type), offset_of!(PerformanceCounterDescriptionKHR, p_next), offset_of!(PerformanceCounterDescriptionKHR, flags), offset_of!(PerformanceCounterDescriptionKHR, name), offset_of!(PerformanceCounterDescriptionKHR, category), offset_of!(PerformanceCounterDescriptionKHR, description));
    println!("QueryPoolPerformanceCreateInfoKHR {} {} {} {} {} {} {}", size_of::<QueryPoolPerformanceCreateInfoKHR>(), align_of::<QueryPoolPerformanceCreateInfoKHR>(), offset_of!(QueryPoolPerformanceCreateInfoKHR, s_type), offset_of!(QueryPoolPerformanceCreateInfoKHR, p_next), offset_of!(QueryPoolPerformanceCreateInfoKHR, queue_family_index), offset_of!(QueryPoolPerformanceCreateInfoKHR, counter_index_count), offset_of!(QueryPoolPerformanceCreateInfoKHR, p_counter_indices));
    println!("PerformanceCounterResultKHR {} {} {} {} {} {} {} {}", size_of::<PerformanceCounterResultKHR>(), align_of::<PerformanceCounterResultKHR>(), offset_of!(PerformanceCounterResultKHR, int32), offset_of!(PerformanceCounterResultKHR, int64), offset_of!(PerformanceCounterResultKHR, uint32), offset_of!(PerformanceCounterResultKHR, uint64), offset_of!(PerformanceCounterResultKHR, float32), offset_of!(PerformanceCounterResultKHR, float64));
    println!("AcquireProfilingLockInfoKHR {} {} {} {} {} {}", size_of::<AcquireProfilingLockInfoKHR>(), align_of::<AcquireProfilingLockInfoKHR>(), offset_of!(AcquireProfilingLockInfoKHR, s_type), offset_of!(AcquireProfilingLockInfoKHR, p_next), offset_of!(AcquireProfilingLockInfoKHR, flags), offset_of!(AcquireProfilingLockInfoKHR, timeout));
    println!("PerformanceQuerySubmitInfoKHR {} {} {} {} {}", size_of::<PerformanceQuerySubmitInfoKHR>(), align_of::<PerformanceQuerySubmitInfoKHR>(), offset_of!(PerformanceQuerySubmitInfoKHR, s_type), offset_of!(PerformanceQuerySubmitInfoKHR, p_next), offset_of!(PerformanceQuerySubmitInfoKHR, counter_pass_index));
    println!("HeadlessSurfaceCreateInfoEXT {} {} {} {} {}", size_of::<HeadlessSurfaceCreateInfoEXT>(), align_of::<HeadlessSurfaceCreateInfoEXT>(), offset_of!(HeadlessSurfaceCreateInfoEXT, s_type), offset_of!(HeadlessSurfaceCreateInfoEXT, p_next), offset_of!(HeadlessSurfaceCreateInfoEXT, flags));
    println!("PhysicalDeviceCoverageReductionModeFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceCoverageReductionModeFeaturesNV>(), align_of::<PhysicalDeviceCoverageReductionModeFeaturesNV>(), offset_of!(PhysicalDeviceCoverageReductionModeFeaturesNV, s_type), offset_of!(PhysicalDeviceCoverageReductionModeFeaturesNV, p_next), offset_of!(PhysicalDeviceCoverageReductionModeFeaturesNV, coverage_reduction_mode));
    println!("PipelineCoverageReductionStateCreateInfoNV {} {} {} {} {} {}", size_of::<PipelineCoverageReductionStateCreateInfoNV>(), align_of::<PipelineCoverageReductionStateCreateInfoNV>(), offset_of!(PipelineCoverageReductionStateCreateInfoNV, s_type), offset_of!(PipelineCoverageReductionStateCreateInfoNV, p_next), offset_of!(PipelineCoverageReductionStateCreateInfoNV, flags), offset_of!(PipelineCoverageReductionStateCreateInfoNV, coverage_reduction_mode));
    println!("FramebufferMixedSamplesCombinationNV {} {} {} {} {} {} {} {}", size_of::<FramebufferMixedSamplesCombinationNV>(), align_of::<FramebufferMixedSamplesCombinationNV>(), offset_of!(FramebufferMixedSamplesCombinationNV, s_type), offset_of!(FramebufferMixedSamplesCombinationNV, p_next), offset_of!(FramebufferMixedSamplesCombinationNV, coverage_reduction_mode), offset_of!(FramebufferMixedSamplesCombinationNV, rasterization_samples), offset_of!(FramebufferMixedSamplesCombinationNV, depth_stencil_samples), offset_of!(FramebufferMixedSamplesCombinationNV, color_samples));
    println!("PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} {} {} {} {}", size_of::<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(), align_of::<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(), offset_of!(PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, s_type), offset_of!(PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, p_next), offset_of!(PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, shader_integer_functions2));
    println!("PerformanceValueDataINTEL {} {} {} {} {} {} {}", size_of::<PerformanceValueDataINTEL>(), align_of::<PerformanceValueDataINTEL>(), offset_of!(PerformanceValueDataINTEL, value32), offset_of!(PerformanceValueDataINTEL, value64), offset_of!(PerformanceValueDataINTEL, value_float), offset_of!(PerformanceValueDataINTEL, value_bool), offset_of!(PerformanceValueDataINTEL, value_string));
    println!("PerformanceValueINTEL {} {} {}", size_of::<PerformanceValueINTEL>(), align_of::<PerformanceValueINTEL>(), offset_of!(PerformanceValueINTEL, data));
    println!("InitializePerformanceApiInfoINTEL {} {} {} {} {}", size_of::<InitializePerformanceApiInfoINTEL>(), align_of::<InitializePerformanceApiInfoINTEL>(), offset_of!(InitializePerformanceApiInfoINTEL, s_type), offset_of!(InitializePerformanceApiInfoINTEL, p_next), offset_of!(InitializePerformanceApiInfoINTEL, p_user_data));
    println!("QueryPoolPerformanceQueryCreateInfoINTEL {} {} {} {} {}", size_of::<QueryPoolPerformanceQueryCreateInfoINTEL>(), align_of::<QueryPoolPerformanceQueryCreateInfoINTEL>(), offset_of!(QueryPoolPerformanceQueryCreateInfoINTEL, s_type), offset_of!(QueryPoolPerformanceQueryCreateInfoINTEL, p_next), offset_of!(QueryPoolPerformanceQueryCreateInfoINTEL, performance_counters_sampling));
    println!("PerformanceMarkerInfoINTEL {} {} {} {} {}", size_of::<PerformanceMarkerInfoINTEL>(), align_of::<PerformanceMarkerInfoINTEL>(), offset_of!(PerformanceMarkerInfoINTEL, s_type), offset_of!(PerformanceMarkerInfoINTEL, p_next), offset_of!(PerformanceMarkerInfoINTEL, marker));
    println!("PerformanceStreamMarkerInfoINTEL {} {} {} {} {}", size_of::<PerformanceStreamMarkerInfoINTEL>(), align_of::<PerformanceStreamMarkerInfoINTEL>(), offset_of!(PerformanceStreamMarkerInfoINTEL, s_type), offset_of!(PerformanceStreamMarkerInfoINTEL, p_next), offset_of!(PerformanceStreamMarkerInfoINTEL, marker));
    println!("PerformanceOverrideInfoINTEL {} {} {} {} {} {}", size_of::<PerformanceOverrideInfoINTEL>(), align_of::<PerformanceOverrideInfoINTEL>(), offset_of!(PerformanceOverrideInfoINTEL, s_type), offset_of!(PerformanceOverrideInfoINTEL, p_next), offset_of!(PerformanceOverrideInfoINTEL, enable), offset_of!(PerformanceOverrideInfoINTEL, parameter));
    println!("PerformanceConfigurationAcquireInfoINTEL {} {} {} {}", size_of::<PerformanceConfigurationAcquireInfoINTEL>(), align_of::<PerformanceConfigurationAcquireInfoINTEL>(), offset_of!(PerformanceConfigurationAcquireInfoINTEL, s_type), offset_of!(PerformanceConfigurationAcquireInfoINTEL, p_next));
    println!("PhysicalDeviceShaderClockFeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderClockFeaturesKHR>(), align_of::<PhysicalDeviceShaderClockFeaturesKHR>(), offset_of!(PhysicalDeviceShaderClockFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderClockFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderClockFeaturesKHR, shader_subgroup_clock), offset_of!(PhysicalDeviceShaderClockFeaturesKHR, shader_device_clock));
    println!("PhysicalDeviceIndexTypeUint8Features {} {} {} {} {}", size_of::<PhysicalDeviceIndexTypeUint8Features>(), align_of::<PhysicalDeviceIndexTypeUint8Features>(), offset_of!(PhysicalDeviceIndexTypeUint8Features, s_type), offset_of!(PhysicalDeviceIndexTypeUint8Features, p_next), offset_of!(PhysicalDeviceIndexTypeUint8Features, index_type_uint8));
    println!("PhysicalDeviceShaderSMBuiltinsPropertiesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderSMBuiltinsPropertiesNV>(), align_of::<PhysicalDeviceShaderSMBuiltinsPropertiesNV>(), offset_of!(PhysicalDeviceShaderSMBuiltinsPropertiesNV, s_type), offset_of!(PhysicalDeviceShaderSMBuiltinsPropertiesNV, p_next), offset_of!(PhysicalDeviceShaderSMBuiltinsPropertiesNV, shader_sm_count), offset_of!(PhysicalDeviceShaderSMBuiltinsPropertiesNV, shader_warps_per_sm));
    println!("PhysicalDeviceShaderSMBuiltinsFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceShaderSMBuiltinsFeaturesNV>(), align_of::<PhysicalDeviceShaderSMBuiltinsFeaturesNV>(), offset_of!(PhysicalDeviceShaderSMBuiltinsFeaturesNV, s_type), offset_of!(PhysicalDeviceShaderSMBuiltinsFeaturesNV, p_next), offset_of!(PhysicalDeviceShaderSMBuiltinsFeaturesNV, shader_sm_builtins));
    println!("PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>(), align_of::<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>(), offset_of!(PhysicalDeviceFragmentShaderInterlockFeaturesEXT, s_type), offset_of!(PhysicalDeviceFragmentShaderInterlockFeaturesEXT, p_next), offset_of!(PhysicalDeviceFragmentShaderInterlockFeaturesEXT, fragment_shader_sample_interlock), offset_of!(PhysicalDeviceFragmentShaderInterlockFeaturesEXT, fragment_shader_pixel_interlock), offset_of!(PhysicalDeviceFragmentShaderInterlockFeaturesEXT, fragment_shader_shading_rate_interlock));
    println!("PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} {} {} {} {}", size_of::<PhysicalDeviceSeparateDepthStencilLayoutsFeatures>(), align_of::<PhysicalDeviceSeparateDepthStencilLayoutsFeatures>(), offset_of!(PhysicalDeviceSeparateDepthStencilLayoutsFeatures, s_type), offset_of!(PhysicalDeviceSeparateDepthStencilLayoutsFeatures, p_next), offset_of!(PhysicalDeviceSeparateDepthStencilLayoutsFeatures, separate_depth_stencil_layouts));
    println!("AttachmentReferenceStencilLayout {} {} {} {} {}", size_of::<AttachmentReferenceStencilLayout>(), align_of::<AttachmentReferenceStencilLayout>(), offset_of!(AttachmentReferenceStencilLayout, s_type), offset_of!(AttachmentReferenceStencilLayout, p_next), offset_of!(AttachmentReferenceStencilLayout, stencil_layout));
    println!("PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(), align_of::<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(), offset_of!(PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, s_type), offset_of!(PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, p_next), offset_of!(PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, primitive_topology_list_restart), offset_of!(PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, primitive_topology_patch_list_restart));
    println!("AttachmentDescriptionStencilLayout {} {} {} {} {} {}", size_of::<AttachmentDescriptionStencilLayout>(), align_of::<AttachmentDescriptionStencilLayout>(), offset_of!(AttachmentDescriptionStencilLayout, s_type), offset_of!(AttachmentDescriptionStencilLayout, p_next), offset_of!(AttachmentDescriptionStencilLayout, stencil_initial_layout), offset_of!(AttachmentDescriptionStencilLayout, stencil_final_layout));
    println!("PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(), align_of::<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(), offset_of!(PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, s_type), offset_of!(PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, p_next), offset_of!(PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, pipeline_executable_info));
    println!("PipelineInfoKHR {} {} {} {} {}", size_of::<PipelineInfoKHR>(), align_of::<PipelineInfoKHR>(), offset_of!(PipelineInfoKHR, s_type), offset_of!(PipelineInfoKHR, p_next), offset_of!(PipelineInfoKHR, pipeline));
    println!("PipelineExecutablePropertiesKHR {} {} {} {} {} {} {} {}", size_of::<PipelineExecutablePropertiesKHR>(), align_of::<PipelineExecutablePropertiesKHR>(), offset_of!(PipelineExecutablePropertiesKHR, s_type), offset_of!(PipelineExecutablePropertiesKHR, p_next), offset_of!(PipelineExecutablePropertiesKHR, stages), offset_of!(PipelineExecutablePropertiesKHR, name), offset_of!(PipelineExecutablePropertiesKHR, description), offset_of!(PipelineExecutablePropertiesKHR, subgroup_size));
    println!("PipelineExecutableInfoKHR {} {} {} {} {} {}", size_of::<PipelineExecutableInfoKHR>(), align_of::<PipelineExecutableInfoKHR>(), offset_of!(PipelineExecutableInfoKHR, s_type), offset_of!(PipelineExecutableInfoKHR, p_next), offset_of!(PipelineExecutableInfoKHR, pipeline), offset_of!(PipelineExecutableInfoKHR, executable_index));
    println!("PipelineExecutableStatisticValueKHR {} {} {} {} {} {}", size_of::<PipelineExecutableStatisticValueKHR>(), align_of::<PipelineExecutableStatisticValueKHR>(), offset_of!(PipelineExecutableStatisticValueKHR, b32), offset_of!(PipelineExecutableStatisticValueKHR, i64), offset_of!(PipelineExecutableStatisticValueKHR, u64), offset_of!(PipelineExecutableStatisticValueKHR, f64));
    println!("PipelineExecutableStatisticKHR {} {} {} {} {} {} {} {}", size_of::<PipelineExecutableStatisticKHR>(), align_of::<PipelineExecutableStatisticKHR>(), offset_of!(PipelineExecutableStatisticKHR, s_type), offset_of!(PipelineExecutableStatisticKHR, p_next), offset_of!(PipelineExecutableStatisticKHR, name), offset_of!(PipelineExecutableStatisticKHR, description), offset_of!(PipelineExecutableStatisticKHR, format), offset_of!(PipelineExecutableStatisticKHR, value));
    println!("PipelineExecutableInternalRepresentationKHR {} {} {} {} {} {} {} {} {}", size_of::<PipelineExecutableInternalRepresentationKHR>(), align_of::<PipelineExecutableInternalRepresentationKHR>(), offset_of!(PipelineExecutableInternalRepresentationKHR, s_type), offset_of!(PipelineExecutableInternalRepresentationKHR, p_next), offset_of!(PipelineExecutableInternalRepresentationKHR, name), offset_of!(PipelineExecutableInternalRepresentationKHR, description), offset_of!(PipelineExecutableInternalRepresentationKHR, is_text), offset_of!(PipelineExecutableInternalRepresentationKHR, data_size), offset_of!(PipelineExecutableInternalRepresentationKHR, p_data));
    println!("PhysicalDeviceShaderDemoteToHelperInvocationFeatures {} {} {} {} {}", size_of::<PhysicalDeviceShaderDemoteToHelperInvocationFeatures>(), align_of::<PhysicalDeviceShaderDemoteToHelperInvocationFeatures>(), offset_of!(PhysicalDeviceShaderDemoteToHelperInvocationFeatures, s_type), offset_of!(PhysicalDeviceShaderDemoteToHelperInvocationFeatures, p_next), offset_of!(PhysicalDeviceShaderDemoteToHelperInvocationFeatures, shader_demote_to_helper_invocation));
    println!("PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>(), align_of::<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>(), offset_of!(PhysicalDeviceTexelBufferAlignmentFeaturesEXT, s_type), offset_of!(PhysicalDeviceTexelBufferAlignmentFeaturesEXT, p_next), offset_of!(PhysicalDeviceTexelBufferAlignmentFeaturesEXT, texel_buffer_alignment));
    println!("PhysicalDeviceTexelBufferAlignmentProperties {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceTexelBufferAlignmentProperties>(), align_of::<PhysicalDeviceTexelBufferAlignmentProperties>(), offset_of!(PhysicalDeviceTexelBufferAlignmentProperties, s_type), offset_of!(PhysicalDeviceTexelBufferAlignmentProperties, p_next), offset_of!(PhysicalDeviceTexelBufferAlignmentProperties, storage_texel_buffer_offset_alignment_bytes), offset_of!(PhysicalDeviceTexelBufferAlignmentProperties, storage_texel_buffer_offset_single_texel_alignment), offset_of!(PhysicalDeviceTexelBufferAlignmentProperties, uniform_texel_buffer_offset_alignment_bytes), offset_of!(PhysicalDeviceTexelBufferAlignmentProperties, uniform_texel_buffer_offset_single_texel_alignment));
    println!("PhysicalDeviceSubgroupSizeControlFeatures {} {} {} {} {} {}", size_of::<PhysicalDeviceSubgroupSizeControlFeatures>(), align_of::<PhysicalDeviceSubgroupSizeControlFeatures>(), offset_of!(PhysicalDeviceSubgroupSizeControlFeatures, s_type), offset_of!(PhysicalDeviceSubgroupSizeControlFeatures, p_next), offset_of!(PhysicalDeviceSubgroupSizeControlFeatures, subgroup_size_control), offset_of!(PhysicalDeviceSubgroupSizeControlFeatures, compute_full_subgroups));
    println!("PhysicalDeviceSubgroupSizeControlProperties {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceSubgroupSizeControlProperties>(), align_of::<PhysicalDeviceSubgroupSizeControlProperties>(), offset_of!(PhysicalDeviceSubgroupSizeControlProperties, s_type), offset_of!(PhysicalDeviceSubgroupSizeControlProperties, p_next), offset_of!(PhysicalDeviceSubgroupSizeControlProperties, min_subgroup_size), offset_of!(PhysicalDeviceSubgroupSizeControlProperties, max_subgroup_size), offset_of!(PhysicalDeviceSubgroupSizeControlProperties, max_compute_workgroup_subgroups), offset_of!(PhysicalDeviceSubgroupSizeControlProperties, required_subgroup_size_stages));
    println!("PipelineShaderStageRequiredSubgroupSizeCreateInfo {} {} {} {} {}", size_of::<PipelineShaderStageRequiredSubgroupSizeCreateInfo>(), align_of::<PipelineShaderStageRequiredSubgroupSizeCreateInfo>(), offset_of!(PipelineShaderStageRequiredSubgroupSizeCreateInfo, s_type), offset_of!(PipelineShaderStageRequiredSubgroupSizeCreateInfo, p_next), offset_of!(PipelineShaderStageRequiredSubgroupSizeCreateInfo, required_subgroup_size));
    println!("SubpassShadingPipelineCreateInfoHUAWEI {} {} {} {} {} {}", size_of::<SubpassShadingPipelineCreateInfoHUAWEI>(), align_of::<SubpassShadingPipelineCreateInfoHUAWEI>(), offset_of!(SubpassShadingPipelineCreateInfoHUAWEI, s_type), offset_of!(SubpassShadingPipelineCreateInfoHUAWEI, p_next), offset_of!(SubpassShadingPipelineCreateInfoHUAWEI, render_pass), offset_of!(SubpassShadingPipelineCreateInfoHUAWEI, subpass));
    println!("PhysicalDeviceSubpassShadingPropertiesHUAWEI {} {} {} {} {}", size_of::<PhysicalDeviceSubpassShadingPropertiesHUAWEI>(), align_of::<PhysicalDeviceSubpassShadingPropertiesHUAWEI>(), offset_of!(PhysicalDeviceSubpassShadingPropertiesHUAWEI, s_type), offset_of!(PhysicalDeviceSubpassShadingPropertiesHUAWEI, p_next), offset_of!(PhysicalDeviceSubpassShadingPropertiesHUAWEI, max_subpass_shading_workgroup_size_aspect_ratio));
    println!("PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceClusterCullingShaderPropertiesHUAWEI>(), align_of::<PhysicalDeviceClusterCullingShaderPropertiesHUAWEI>(), offset_of!(PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, s_type), offset_of!(PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, p_next), offset_of!(PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, max_work_group_count), offset_of!(PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, max_work_group_size), offset_of!(PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, max_output_cluster_count), offset_of!(PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, indirect_buffer_offset_alignment));
    println!("MemoryOpaqueCaptureAddressAllocateInfo {} {} {} {} {}", size_of::<MemoryOpaqueCaptureAddressAllocateInfo>(), align_of::<MemoryOpaqueCaptureAddressAllocateInfo>(), offset_of!(MemoryOpaqueCaptureAddressAllocateInfo, s_type), offset_of!(MemoryOpaqueCaptureAddressAllocateInfo, p_next), offset_of!(MemoryOpaqueCaptureAddressAllocateInfo, opaque_capture_address));
    println!("DeviceMemoryOpaqueCaptureAddressInfo {} {} {} {} {}", size_of::<DeviceMemoryOpaqueCaptureAddressInfo>(), align_of::<DeviceMemoryOpaqueCaptureAddressInfo>(), offset_of!(DeviceMemoryOpaqueCaptureAddressInfo, s_type), offset_of!(DeviceMemoryOpaqueCaptureAddressInfo, p_next), offset_of!(DeviceMemoryOpaqueCaptureAddressInfo, memory));
    println!("PhysicalDeviceLineRasterizationFeatures {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceLineRasterizationFeatures>(), align_of::<PhysicalDeviceLineRasterizationFeatures>(), offset_of!(PhysicalDeviceLineRasterizationFeatures, s_type), offset_of!(PhysicalDeviceLineRasterizationFeatures, p_next), offset_of!(PhysicalDeviceLineRasterizationFeatures, rectangular_lines), offset_of!(PhysicalDeviceLineRasterizationFeatures, bresenham_lines), offset_of!(PhysicalDeviceLineRasterizationFeatures, smooth_lines), offset_of!(PhysicalDeviceLineRasterizationFeatures, stippled_rectangular_lines), offset_of!(PhysicalDeviceLineRasterizationFeatures, stippled_bresenham_lines), offset_of!(PhysicalDeviceLineRasterizationFeatures, stippled_smooth_lines));
    println!("PhysicalDeviceLineRasterizationProperties {} {} {} {} {}", size_of::<PhysicalDeviceLineRasterizationProperties>(), align_of::<PhysicalDeviceLineRasterizationProperties>(), offset_of!(PhysicalDeviceLineRasterizationProperties, s_type), offset_of!(PhysicalDeviceLineRasterizationProperties, p_next), offset_of!(PhysicalDeviceLineRasterizationProperties, line_sub_pixel_precision_bits));
    println!("PipelineRasterizationLineStateCreateInfo {} {} {} {} {} {} {} {}", size_of::<PipelineRasterizationLineStateCreateInfo>(), align_of::<PipelineRasterizationLineStateCreateInfo>(), offset_of!(PipelineRasterizationLineStateCreateInfo, s_type), offset_of!(PipelineRasterizationLineStateCreateInfo, p_next), offset_of!(PipelineRasterizationLineStateCreateInfo, line_rasterization_mode), offset_of!(PipelineRasterizationLineStateCreateInfo, stippled_line_enable), offset_of!(PipelineRasterizationLineStateCreateInfo, line_stipple_factor), offset_of!(PipelineRasterizationLineStateCreateInfo, line_stipple_pattern));
    println!("PhysicalDevicePipelineCreationCacheControlFeatures {} {} {} {} {}", size_of::<PhysicalDevicePipelineCreationCacheControlFeatures>(), align_of::<PhysicalDevicePipelineCreationCacheControlFeatures>(), offset_of!(PhysicalDevicePipelineCreationCacheControlFeatures, s_type), offset_of!(PhysicalDevicePipelineCreationCacheControlFeatures, p_next), offset_of!(PhysicalDevicePipelineCreationCacheControlFeatures, pipeline_creation_cache_control));
    println!("PhysicalDeviceVulkan11Features {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan11Features>(), align_of::<PhysicalDeviceVulkan11Features>(), offset_of!(PhysicalDeviceVulkan11Features, s_type), offset_of!(PhysicalDeviceVulkan11Features, p_next), offset_of!(PhysicalDeviceVulkan11Features, storage_buffer16_bit_access), offset_of!(PhysicalDeviceVulkan11Features, uniform_and_storage_buffer16_bit_access), offset_of!(PhysicalDeviceVulkan11Features, storage_push_constant16), offset_of!(PhysicalDeviceVulkan11Features, storage_input_output16), offset_of!(PhysicalDeviceVulkan11Features, multiview), offset_of!(PhysicalDeviceVulkan11Features, multiview_geometry_shader), offset_of!(PhysicalDeviceVulkan11Features, multiview_tessellation_shader), offset_of!(PhysicalDeviceVulkan11Features, variable_pointers_storage_buffer), offset_of!(PhysicalDeviceVulkan11Features, variable_pointers), offset_of!(PhysicalDeviceVulkan11Features, protected_memory), offset_of!(PhysicalDeviceVulkan11Features, sampler_ycbcr_conversion), offset_of!(PhysicalDeviceVulkan11Features, shader_draw_parameters));
    println!("PhysicalDeviceVulkan11Properties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan11Properties>(), align_of::<PhysicalDeviceVulkan11Properties>(), offset_of!(PhysicalDeviceVulkan11Properties, s_type), offset_of!(PhysicalDeviceVulkan11Properties, p_next), offset_of!(PhysicalDeviceVulkan11Properties, device_uuid), offset_of!(PhysicalDeviceVulkan11Properties, driver_uuid), offset_of!(PhysicalDeviceVulkan11Properties, device_luid), offset_of!(PhysicalDeviceVulkan11Properties, device_node_mask), offset_of!(PhysicalDeviceVulkan11Properties, device_luid_valid), offset_of!(PhysicalDeviceVulkan11Properties, subgroup_size), offset_of!(PhysicalDeviceVulkan11Properties, subgroup_supported_stages), offset_of!(PhysicalDeviceVulkan11Properties, subgroup_supported_operations), offset_of!(PhysicalDeviceVulkan11Properties, subgroup_quad_operations_in_all_stages), offset_of!(PhysicalDeviceVulkan11Properties, point_clipping_behavior), offset_of!(PhysicalDeviceVulkan11Properties, max_multiview_view_count), offset_of!(PhysicalDeviceVulkan11Properties, max_multiview_instance_index), offset_of!(PhysicalDeviceVulkan11Properties, protected_no_fault), offset_of!(PhysicalDeviceVulkan11Properties, max_per_set_descriptors), offset_of!(PhysicalDeviceVulkan11Properties, max_memory_allocation_size));
    println!("PhysicalDeviceVulkan12Features {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan12Features>(), align_of::<PhysicalDeviceVulkan12Features>(), offset_of!(PhysicalDeviceVulkan12Features, s_type), offset_of!(PhysicalDeviceVulkan12Features, p_next), offset_of!(PhysicalDeviceVulkan12Features, sampler_mirror_clamp_to_edge), offset_of!(PhysicalDeviceVulkan12Features, draw_indirect_count), offset_of!(PhysicalDeviceVulkan12Features, storage_buffer8_bit_access), offset_of!(PhysicalDeviceVulkan12Features, uniform_and_storage_buffer8_bit_access), offset_of!(PhysicalDeviceVulkan12Features, storage_push_constant8), offset_of!(PhysicalDeviceVulkan12Features, shader_buffer_int64_atomics), offset_of!(PhysicalDeviceVulkan12Features, shader_shared_int64_atomics), offset_of!(PhysicalDeviceVulkan12Features, shader_float16), offset_of!(PhysicalDeviceVulkan12Features, shader_int8), offset_of!(PhysicalDeviceVulkan12Features, descriptor_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_input_attachment_array_dynamic_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_uniform_texel_buffer_array_dynamic_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_storage_texel_buffer_array_dynamic_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_uniform_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_sampled_image_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_storage_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_storage_image_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_input_attachment_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_uniform_texel_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, shader_storage_texel_buffer_array_non_uniform_indexing), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_uniform_buffer_update_after_bind), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_sampled_image_update_after_bind), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_storage_image_update_after_bind), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_storage_buffer_update_after_bind), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_uniform_texel_buffer_update_after_bind), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_storage_texel_buffer_update_after_bind), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_update_unused_while_pending), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_partially_bound), offset_of!(PhysicalDeviceVulkan12Features, descriptor_binding_variable_descriptor_count), offset_of!(PhysicalDeviceVulkan12Features, runtime_descriptor_array), offset_of!(PhysicalDeviceVulkan12Features, sampler_filter_minmax), offset_of!(PhysicalDeviceVulkan12Features, scalar_block_layout), offset_of!(PhysicalDeviceVulkan12Features, imageless_framebuffer), offset_of!(PhysicalDeviceVulkan12Features, uniform_buffer_standard_layout), offset_of!(PhysicalDeviceVulkan12Features, shader_subgroup_extended_types), offset_of!(PhysicalDeviceVulkan12Features, separate_depth_stencil_layouts), offset_of!(PhysicalDeviceVulkan12Features, host_query_reset), offset_of!(PhysicalDeviceVulkan12Features, timeline_semaphore), offset_of!(PhysicalDeviceVulkan12Features, buffer_device_address), offset_of!(PhysicalDeviceVulkan12Features, buffer_device_address_capture_replay), offset_of!(PhysicalDeviceVulkan12Features, buffer_device_address_multi_device), offset_of!(PhysicalDeviceVulkan12Features, vulkan_memory_model), offset_of!(PhysicalDeviceVulkan12Features, vulkan_memory_model_device_scope), offset_of!(PhysicalDeviceVulkan12Features, vulkan_memory_model_availability_visibility_chains), offset_of!(PhysicalDeviceVulkan12Features, shader_output_viewport_index), offset_of!(PhysicalDeviceVulkan12Features, shader_output_layer), offset_of!(PhysicalDeviceVulkan12Features, subgroup_broadcast_dynamic_id));
    println!("PhysicalDeviceVulkan12Properties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan12Properties>(), align_of::<PhysicalDeviceVulkan12Properties>(), offset_of!(PhysicalDeviceVulkan12Properties, s_type), offset_of!(PhysicalDeviceVulkan12Properties, p_next), offset_of!(PhysicalDeviceVulkan12Properties, driver_id), offset_of!(PhysicalDeviceVulkan12Properties, driver_name), offset_of!(PhysicalDeviceVulkan12Properties, driver_info), offset_of!(PhysicalDeviceVulkan12Properties, conformance_version), offset_of!(PhysicalDeviceVulkan12Properties, denorm_behavior_independence), offset_of!(PhysicalDeviceVulkan12Properties, rounding_mode_independence), offset_of!(PhysicalDeviceVulkan12Properties, shader_signed_zero_inf_nan_preserve_float16), offset_of!(PhysicalDeviceVulkan12Properties, shader_signed_zero_inf_nan_preserve_float32), offset_of!(PhysicalDeviceVulkan12Properties, shader_signed_zero_inf_nan_preserve_float64), offset_of!(PhysicalDeviceVulkan12Properties, shader_denorm_preserve_float16), offset_of!(PhysicalDeviceVulkan12Properties, shader_denorm_preserve_float32), offset_of!(PhysicalDeviceVulkan12Properties, shader_denorm_preserve_float64), offset_of!(PhysicalDeviceVulkan12Properties, shader_denorm_flush_to_zero_float16), offset_of!(PhysicalDeviceVulkan12Properties, shader_denorm_flush_to_zero_float32), offset_of!(PhysicalDeviceVulkan12Properties, shader_denorm_flush_to_zero_float64), offset_of!(PhysicalDeviceVulkan12Properties, shader_rounding_mode_rte_float16), offset_of!(PhysicalDeviceVulkan12Properties, shader_rounding_mode_rte_float32), offset_of!(PhysicalDeviceVulkan12Properties, shader_rounding_mode_rte_float64), offset_of!(PhysicalDeviceVulkan12Properties, shader_rounding_mode_rtz_float16), offset_of!(PhysicalDeviceVulkan12Properties, shader_rounding_mode_rtz_float32), offset_of!(PhysicalDeviceVulkan12Properties, shader_rounding_mode_rtz_float64), offset_of!(PhysicalDeviceVulkan12Properties, max_update_after_bind_descriptors_in_all_pools), offset_of!(PhysicalDeviceVulkan12Properties, shader_uniform_buffer_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceVulkan12Properties, shader_sampled_image_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceVulkan12Properties, shader_storage_buffer_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceVulkan12Properties, shader_storage_image_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceVulkan12Properties, shader_input_attachment_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceVulkan12Properties, robust_buffer_access_update_after_bind), offset_of!(PhysicalDeviceVulkan12Properties, quad_divergent_implicit_lod), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_descriptor_update_after_bind_samplers), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_descriptor_update_after_bind_uniform_buffers), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_descriptor_update_after_bind_storage_buffers), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_descriptor_update_after_bind_sampled_images), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_descriptor_update_after_bind_storage_images), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_descriptor_update_after_bind_input_attachments), offset_of!(PhysicalDeviceVulkan12Properties, max_per_stage_update_after_bind_resources), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_samplers), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_uniform_buffers), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_uniform_buffers_dynamic), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_storage_buffers), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_storage_buffers_dynamic), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_sampled_images), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_storage_images), offset_of!(PhysicalDeviceVulkan12Properties, max_descriptor_set_update_after_bind_input_attachments), offset_of!(PhysicalDeviceVulkan12Properties, supported_depth_resolve_modes), offset_of!(PhysicalDeviceVulkan12Properties, supported_stencil_resolve_modes), offset_of!(PhysicalDeviceVulkan12Properties, independent_resolve_none), offset_of!(PhysicalDeviceVulkan12Properties, independent_resolve), offset_of!(PhysicalDeviceVulkan12Properties, filter_minmax_single_component_formats), offset_of!(PhysicalDeviceVulkan12Properties, filter_minmax_image_component_mapping), offset_of!(PhysicalDeviceVulkan12Properties, max_timeline_semaphore_value_difference), offset_of!(PhysicalDeviceVulkan12Properties, framebuffer_integer_color_sample_counts));
    println!("PhysicalDeviceVulkan13Features {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan13Features>(), align_of::<PhysicalDeviceVulkan13Features>(), offset_of!(PhysicalDeviceVulkan13Features, s_type), offset_of!(PhysicalDeviceVulkan13Features, p_next), offset_of!(PhysicalDeviceVulkan13Features, robust_image_access), offset_of!(PhysicalDeviceVulkan13Features, inline_uniform_block), offset_of!(PhysicalDeviceVulkan13Features, descriptor_binding_inline_uniform_block_update_after_bind), offset_of!(PhysicalDeviceVulkan13Features, pipeline_creation_cache_control), offset_of!(PhysicalDeviceVulkan13Features, private_data), offset_of!(PhysicalDeviceVulkan13Features, shader_demote_to_helper_invocation), offset_of!(PhysicalDeviceVulkan13Features, shader_terminate_invocation), offset_of!(PhysicalDeviceVulkan13Features, subgroup_size_control), offset_of!(PhysicalDeviceVulkan13Features, compute_full_subgroups), offset_of!(PhysicalDeviceVulkan13Features, synchronization2), offset_of!(PhysicalDeviceVulkan13Features, texture_compression_astc_hdr), offset_of!(PhysicalDeviceVulkan13Features, shader_zero_initialize_workgroup_memory), offset_of!(PhysicalDeviceVulkan13Features, dynamic_rendering), offset_of!(PhysicalDeviceVulkan13Features, shader_integer_dot_product), offset_of!(PhysicalDeviceVulkan13Features, maintenance4));
    println!("PhysicalDeviceVulkan13Properties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan13Properties>(), align_of::<PhysicalDeviceVulkan13Properties>(), offset_of!(PhysicalDeviceVulkan13Properties, s_type), offset_of!(PhysicalDeviceVulkan13Properties, p_next), offset_of!(PhysicalDeviceVulkan13Properties, min_subgroup_size), offset_of!(PhysicalDeviceVulkan13Properties, max_subgroup_size), offset_of!(PhysicalDeviceVulkan13Properties, max_compute_workgroup_subgroups), offset_of!(PhysicalDeviceVulkan13Properties, required_subgroup_size_stages), offset_of!(PhysicalDeviceVulkan13Properties, max_inline_uniform_block_size), offset_of!(PhysicalDeviceVulkan13Properties, max_per_stage_descriptor_inline_uniform_blocks), offset_of!(PhysicalDeviceVulkan13Properties, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks), offset_of!(PhysicalDeviceVulkan13Properties, max_descriptor_set_inline_uniform_blocks), offset_of!(PhysicalDeviceVulkan13Properties, max_descriptor_set_update_after_bind_inline_uniform_blocks), offset_of!(PhysicalDeviceVulkan13Properties, max_inline_uniform_total_size), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product8_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product8_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product8_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product4x8_bit_packed_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product4x8_bit_packed_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product4x8_bit_packed_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product16_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product16_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product16_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product32_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product32_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product32_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product64_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product64_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product64_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating8_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating16_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating32_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating64_bit_signed_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceVulkan13Properties, storage_texel_buffer_offset_alignment_bytes), offset_of!(PhysicalDeviceVulkan13Properties, storage_texel_buffer_offset_single_texel_alignment), offset_of!(PhysicalDeviceVulkan13Properties, uniform_texel_buffer_offset_alignment_bytes), offset_of!(PhysicalDeviceVulkan13Properties, uniform_texel_buffer_offset_single_texel_alignment), offset_of!(PhysicalDeviceVulkan13Properties, max_buffer_size));
    println!("PhysicalDeviceVulkan14Features {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan14Features>(), align_of::<PhysicalDeviceVulkan14Features>(), offset_of!(PhysicalDeviceVulkan14Features, s_type), offset_of!(PhysicalDeviceVulkan14Features, p_next), offset_of!(PhysicalDeviceVulkan14Features, global_priority_query), offset_of!(PhysicalDeviceVulkan14Features, shader_subgroup_rotate), offset_of!(PhysicalDeviceVulkan14Features, shader_subgroup_rotate_clustered), offset_of!(PhysicalDeviceVulkan14Features, shader_float_controls2), offset_of!(PhysicalDeviceVulkan14Features, shader_expect_assume), offset_of!(PhysicalDeviceVulkan14Features, rectangular_lines), offset_of!(PhysicalDeviceVulkan14Features, bresenham_lines), offset_of!(PhysicalDeviceVulkan14Features, smooth_lines), offset_of!(PhysicalDeviceVulkan14Features, stippled_rectangular_lines), offset_of!(PhysicalDeviceVulkan14Features, stippled_bresenham_lines), offset_of!(PhysicalDeviceVulkan14Features, stippled_smooth_lines), offset_of!(PhysicalDeviceVulkan14Features, vertex_attribute_instance_rate_divisor), offset_of!(PhysicalDeviceVulkan14Features, vertex_attribute_instance_rate_zero_divisor), offset_of!(PhysicalDeviceVulkan14Features, index_type_uint8), offset_of!(PhysicalDeviceVulkan14Features, dynamic_rendering_local_read), offset_of!(PhysicalDeviceVulkan14Features, maintenance5), offset_of!(PhysicalDeviceVulkan14Features, maintenance6), offset_of!(PhysicalDeviceVulkan14Features, pipeline_protected_access), offset_of!(PhysicalDeviceVulkan14Features, pipeline_robustness), offset_of!(PhysicalDeviceVulkan14Features, host_image_copy), offset_of!(PhysicalDeviceVulkan14Features, push_descriptor));
    println!("PhysicalDeviceVulkan14Properties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceVulkan14Properties>(), align_of::<PhysicalDeviceVulkan14Properties>(), offset_of!(PhysicalDeviceVulkan14Properties, s_type), offset_of!(PhysicalDeviceVulkan14Properties, p_next), offset_of!(PhysicalDeviceVulkan14Properties, line_sub_pixel_precision_bits), offset_of!(PhysicalDeviceVulkan14Properties, max_vertex_attrib_divisor), offset_of!(PhysicalDeviceVulkan14Properties, supports_non_zero_first_instance), offset_of!(PhysicalDeviceVulkan14Properties, max_push_descriptors), offset_of!(PhysicalDeviceVulkan14Properties, dynamic_rendering_local_read_depth_stencil_attachments), offset_of!(PhysicalDeviceVulkan14Properties, dynamic_rendering_local_read_multisampled_attachments), offset_of!(PhysicalDeviceVulkan14Properties, early_fragment_multisample_coverage_after_sample_counting), offset_of!(PhysicalDeviceVulkan14Properties, early_fragment_sample_mask_test_before_sample_counting), offset_of!(PhysicalDeviceVulkan14Properties, depth_stencil_swizzle_one_support), offset_of!(PhysicalDeviceVulkan14Properties, polygon_mode_point_size), offset_of!(PhysicalDeviceVulkan14Properties, non_strict_single_pixel_wide_lines_use_parallelogram), offset_of!(PhysicalDeviceVulkan14Properties, non_strict_wide_lines_use_parallelogram), offset_of!(PhysicalDeviceVulkan14Properties, block_texel_view_compatible_multiple_layers), offset_of!(PhysicalDeviceVulkan14Properties, max_combined_image_sampler_descriptor_count), offset_of!(PhysicalDeviceVulkan14Properties, fragment_shading_rate_clamp_combiner_inputs), offset_of!(PhysicalDeviceVulkan14Properties, default_robustness_storage_buffers), offset_of!(PhysicalDeviceVulkan14Properties, default_robustness_uniform_buffers), offset_of!(PhysicalDeviceVulkan14Properties, default_robustness_vertex_inputs), offset_of!(PhysicalDeviceVulkan14Properties, default_robustness_images), offset_of!(PhysicalDeviceVulkan14Properties, copy_src_layout_count), offset_of!(PhysicalDeviceVulkan14Properties, p_copy_src_layouts), offset_of!(PhysicalDeviceVulkan14Properties, copy_dst_layout_count), offset_of!(PhysicalDeviceVulkan14Properties, p_copy_dst_layouts), offset_of!(PhysicalDeviceVulkan14Properties, optimal_tiling_layout_uuid), offset_of!(PhysicalDeviceVulkan14Properties, identical_memory_type_requirements));
    println!("PipelineCompilerControlCreateInfoAMD {} {} {} {} {}", size_of::<PipelineCompilerControlCreateInfoAMD>(), align_of::<PipelineCompilerControlCreateInfoAMD>(), offset_of!(PipelineCompilerControlCreateInfoAMD, s_type), offset_of!(PipelineCompilerControlCreateInfoAMD, p_next), offset_of!(PipelineCompilerControlCreateInfoAMD, compiler_control_flags));
    println!("PhysicalDeviceCoherentMemoryFeaturesAMD {} {} {} {} {}", size_of::<PhysicalDeviceCoherentMemoryFeaturesAMD>(), align_of::<PhysicalDeviceCoherentMemoryFeaturesAMD>(), offset_of!(PhysicalDeviceCoherentMemoryFeaturesAMD, s_type), offset_of!(PhysicalDeviceCoherentMemoryFeaturesAMD, p_next), offset_of!(PhysicalDeviceCoherentMemoryFeaturesAMD, device_coherent_memory));
    println!("PhysicalDeviceToolProperties {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceToolProperties>(), align_of::<PhysicalDeviceToolProperties>(), offset_of!(PhysicalDeviceToolProperties, s_type), offset_of!(PhysicalDeviceToolProperties, p_next), offset_of!(PhysicalDeviceToolProperties, name), offset_of!(PhysicalDeviceToolProperties, version), offset_of!(PhysicalDeviceToolProperties, purposes), offset_of!(PhysicalDeviceToolProperties, description), offset_of!(PhysicalDeviceToolProperties, layer));
    println!("SamplerCustomBorderColorCreateInfoEXT {} {} {} {} {} {}", size_of::<SamplerCustomBorderColorCreateInfoEXT>(), align_of::<SamplerCustomBorderColorCreateInfoEXT>(), offset_of!(SamplerCustomBorderColorCreateInfoEXT, s_type), offset_of!(SamplerCustomBorderColorCreateInfoEXT, p_next), offset_of!(SamplerCustomBorderColorCreateInfoEXT, custom_border_color), offset_of!(SamplerCustomBorderColorCreateInfoEXT, format));
    println!("PhysicalDeviceCustomBorderColorPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceCustomBorderColorPropertiesEXT>(), align_of::<PhysicalDeviceCustomBorderColorPropertiesEXT>(), offset_of!(PhysicalDeviceCustomBorderColorPropertiesEXT, s_type), offset_of!(PhysicalDeviceCustomBorderColorPropertiesEXT, p_next), offset_of!(PhysicalDeviceCustomBorderColorPropertiesEXT, max_custom_border_color_samplers));
    println!("PhysicalDeviceCustomBorderColorFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceCustomBorderColorFeaturesEXT>(), align_of::<PhysicalDeviceCustomBorderColorFeaturesEXT>(), offset_of!(PhysicalDeviceCustomBorderColorFeaturesEXT, s_type), offset_of!(PhysicalDeviceCustomBorderColorFeaturesEXT, p_next), offset_of!(PhysicalDeviceCustomBorderColorFeaturesEXT, custom_border_colors), offset_of!(PhysicalDeviceCustomBorderColorFeaturesEXT, custom_border_color_without_format));
    println!("SamplerBorderColorComponentMappingCreateInfoEXT {} {} {} {} {} {}", size_of::<SamplerBorderColorComponentMappingCreateInfoEXT>(), align_of::<SamplerBorderColorComponentMappingCreateInfoEXT>(), offset_of!(SamplerBorderColorComponentMappingCreateInfoEXT, s_type), offset_of!(SamplerBorderColorComponentMappingCreateInfoEXT, p_next), offset_of!(SamplerBorderColorComponentMappingCreateInfoEXT, components), offset_of!(SamplerBorderColorComponentMappingCreateInfoEXT, srgb));
    println!("PhysicalDeviceBorderColorSwizzleFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceBorderColorSwizzleFeaturesEXT>(), align_of::<PhysicalDeviceBorderColorSwizzleFeaturesEXT>(), offset_of!(PhysicalDeviceBorderColorSwizzleFeaturesEXT, s_type), offset_of!(PhysicalDeviceBorderColorSwizzleFeaturesEXT, p_next), offset_of!(PhysicalDeviceBorderColorSwizzleFeaturesEXT, border_color_swizzle), offset_of!(PhysicalDeviceBorderColorSwizzleFeaturesEXT, border_color_swizzle_from_image));
    println!("DeviceOrHostAddressKHR {} {} {} {}", size_of::<DeviceOrHostAddressKHR>(), align_of::<DeviceOrHostAddressKHR>(), offset_of!(DeviceOrHostAddressKHR, device_address), offset_of!(DeviceOrHostAddressKHR, host_address));
    println!("DeviceOrHostAddressConstKHR {} {} {} {}", size_of::<DeviceOrHostAddressConstKHR>(), align_of::<DeviceOrHostAddressConstKHR>(), offset_of!(DeviceOrHostAddressConstKHR, device_address), offset_of!(DeviceOrHostAddressConstKHR, host_address));
    println!("AccelerationStructureGeometryTrianglesDataKHR {} {} {} {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureGeometryTrianglesDataKHR>(), align_of::<AccelerationStructureGeometryTrianglesDataKHR>(), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, s_type), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, p_next), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, vertex_format), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, vertex_data), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, vertex_stride), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, max_vertex), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, index_type), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, index_data), offset_of!(AccelerationStructureGeometryTrianglesDataKHR, transform_data));
    println!("AccelerationStructureGeometryAabbsDataKHR {} {} {} {} {} {}", size_of::<AccelerationStructureGeometryAabbsDataKHR>(), align_of::<AccelerationStructureGeometryAabbsDataKHR>(), offset_of!(AccelerationStructureGeometryAabbsDataKHR, s_type), offset_of!(AccelerationStructureGeometryAabbsDataKHR, p_next), offset_of!(AccelerationStructureGeometryAabbsDataKHR, data), offset_of!(AccelerationStructureGeometryAabbsDataKHR, stride));
    println!("AccelerationStructureGeometryInstancesDataKHR {} {} {} {} {} {}", size_of::<AccelerationStructureGeometryInstancesDataKHR>(), align_of::<AccelerationStructureGeometryInstancesDataKHR>(), offset_of!(AccelerationStructureGeometryInstancesDataKHR, s_type), offset_of!(AccelerationStructureGeometryInstancesDataKHR, p_next), offset_of!(AccelerationStructureGeometryInstancesDataKHR, array_of_pointers), offset_of!(AccelerationStructureGeometryInstancesDataKHR, data));
    println!("AccelerationStructureGeometryLinearSweptSpheresDataNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureGeometryLinearSweptSpheresDataNV>(), align_of::<AccelerationStructureGeometryLinearSweptSpheresDataNV>(), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, s_type), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, p_next), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, vertex_format), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, vertex_data), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, vertex_stride), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, radius_format), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, radius_data), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, radius_stride), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, index_type), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, index_data), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, index_stride), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, indexing_mode), offset_of!(AccelerationStructureGeometryLinearSweptSpheresDataNV, end_caps_mode));
    println!("AccelerationStructureGeometrySpheresDataNV {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureGeometrySpheresDataNV>(), align_of::<AccelerationStructureGeometrySpheresDataNV>(), offset_of!(AccelerationStructureGeometrySpheresDataNV, s_type), offset_of!(AccelerationStructureGeometrySpheresDataNV, p_next), offset_of!(AccelerationStructureGeometrySpheresDataNV, vertex_format), offset_of!(AccelerationStructureGeometrySpheresDataNV, vertex_data), offset_of!(AccelerationStructureGeometrySpheresDataNV, vertex_stride), offset_of!(AccelerationStructureGeometrySpheresDataNV, radius_format), offset_of!(AccelerationStructureGeometrySpheresDataNV, radius_data), offset_of!(AccelerationStructureGeometrySpheresDataNV, radius_stride), offset_of!(AccelerationStructureGeometrySpheresDataNV, index_type), offset_of!(AccelerationStructureGeometrySpheresDataNV, index_data), offset_of!(AccelerationStructureGeometrySpheresDataNV, index_stride));
    println!("AccelerationStructureGeometryDataKHR {} {} {} {} {}", size_of::<AccelerationStructureGeometryDataKHR>(), align_of::<AccelerationStructureGeometryDataKHR>(), offset_of!(AccelerationStructureGeometryDataKHR, triangles), offset_of!(AccelerationStructureGeometryDataKHR, aabbs), offset_of!(AccelerationStructureGeometryDataKHR, instances));
    println!("AccelerationStructureGeometryKHR {} {} {} {} {} {} {}", size_of::<AccelerationStructureGeometryKHR>(), align_of::<AccelerationStructureGeometryKHR>(), offset_of!(AccelerationStructureGeometryKHR, s_type), offset_of!(AccelerationStructureGeometryKHR, p_next), offset_of!(AccelerationStructureGeometryKHR, geometry_type), offset_of!(AccelerationStructureGeometryKHR, geometry), offset_of!(AccelerationStructureGeometryKHR, flags));
    println!("AccelerationStructureBuildGeometryInfoKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureBuildGeometryInfoKHR>(), align_of::<AccelerationStructureBuildGeometryInfoKHR>(), offset_of!(AccelerationStructureBuildGeometryInfoKHR, s_type), offset_of!(AccelerationStructureBuildGeometryInfoKHR, p_next), offset_of!(AccelerationStructureBuildGeometryInfoKHR, flags), offset_of!(AccelerationStructureBuildGeometryInfoKHR, mode), offset_of!(AccelerationStructureBuildGeometryInfoKHR, src_acceleration_structure), offset_of!(AccelerationStructureBuildGeometryInfoKHR, dst_acceleration_structure), offset_of!(AccelerationStructureBuildGeometryInfoKHR, geometry_count), offset_of!(AccelerationStructureBuildGeometryInfoKHR, p_geometries), offset_of!(AccelerationStructureBuildGeometryInfoKHR, pp_geometries), offset_of!(AccelerationStructureBuildGeometryInfoKHR, scratch_data));
    println!("AccelerationStructureBuildRangeInfoKHR {} {} {} {} {} {}", size_of::<AccelerationStructureBuildRangeInfoKHR>(), align_of::<AccelerationStructureBuildRangeInfoKHR>(), offset_of!(AccelerationStructureBuildRangeInfoKHR, primitive_count), offset_of!(AccelerationStructureBuildRangeInfoKHR, primitive_offset), offset_of!(AccelerationStructureBuildRangeInfoKHR, first_vertex), offset_of!(AccelerationStructureBuildRangeInfoKHR, transform_offset));
    println!("AccelerationStructureCreateInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureCreateInfoKHR>(), align_of::<AccelerationStructureCreateInfoKHR>(), offset_of!(AccelerationStructureCreateInfoKHR, s_type), offset_of!(AccelerationStructureCreateInfoKHR, p_next), offset_of!(AccelerationStructureCreateInfoKHR, create_flags), offset_of!(AccelerationStructureCreateInfoKHR, buffer), offset_of!(AccelerationStructureCreateInfoKHR, offset), offset_of!(AccelerationStructureCreateInfoKHR, size), offset_of!(AccelerationStructureCreateInfoKHR, device_address));
    println!("AabbPositionsKHR {} {} {} {} {} {} {} {}", size_of::<AabbPositionsKHR>(), align_of::<AabbPositionsKHR>(), offset_of!(AabbPositionsKHR, min_x), offset_of!(AabbPositionsKHR, min_y), offset_of!(AabbPositionsKHR, min_z), offset_of!(AabbPositionsKHR, max_x), offset_of!(AabbPositionsKHR, max_y), offset_of!(AabbPositionsKHR, max_z));
    println!("TransformMatrixKHR {} {} {}", size_of::<TransformMatrixKHR>(), align_of::<TransformMatrixKHR>(), offset_of!(TransformMatrixKHR, matrix));
    println!("AccelerationStructureInstanceKHR {} {}", size_of::<AccelerationStructureInstanceKHR>(), align_of::<AccelerationStructureInstanceKHR>());
    println!("AccelerationStructureDeviceAddressInfoKHR {} {} {} {} {}", size_of::<AccelerationStructureDeviceAddressInfoKHR>(), align_of::<AccelerationStructureDeviceAddressInfoKHR>(), offset_of!(AccelerationStructureDeviceAddressInfoKHR, s_type), offset_of!(AccelerationStructureDeviceAddressInfoKHR, p_next), offset_of!(AccelerationStructureDeviceAddressInfoKHR, acceleration_structure));
    println!("AccelerationStructureVersionInfoKHR {} {} {} {} {}", size_of::<AccelerationStructureVersionInfoKHR>(), align_of::<AccelerationStructureVersionInfoKHR>(), offset_of!(AccelerationStructureVersionInfoKHR, s_type), offset_of!(AccelerationStructureVersionInfoKHR, p_next), offset_of!(AccelerationStructureVersionInfoKHR, p_version_data));
    println!("CopyAccelerationStructureInfoKHR {} {} {} {} {} {} {}", size_of::<CopyAccelerationStructureInfoKHR>(), align_of::<CopyAccelerationStructureInfoKHR>(), offset_of!(CopyAccelerationStructureInfoKHR, s_type), offset_of!(CopyAccelerationStructureInfoKHR, p_next), offset_of!(CopyAccelerationStructureInfoKHR, src), offset_of!(CopyAccelerationStructureInfoKHR, dst), offset_of!(CopyAccelerationStructureInfoKHR, mode));
    println!("CopyAccelerationStructureToMemoryInfoKHR {} {} {} {} {} {} {}", size_of::<CopyAccelerationStructureToMemoryInfoKHR>(), align_of::<CopyAccelerationStructureToMemoryInfoKHR>(), offset_of!(CopyAccelerationStructureToMemoryInfoKHR, s_type), offset_of!(CopyAccelerationStructureToMemoryInfoKHR, p_next), offset_of!(CopyAccelerationStructureToMemoryInfoKHR, src), offset_of!(CopyAccelerationStructureToMemoryInfoKHR, dst), offset_of!(CopyAccelerationStructureToMemoryInfoKHR, mode));
    println!("CopyMemoryToAccelerationStructureInfoKHR {} {} {} {} {} {} {}", size_of::<CopyMemoryToAccelerationStructureInfoKHR>(), align_of::<CopyMemoryToAccelerationStructureInfoKHR>(), offset_of!(CopyMemoryToAccelerationStructureInfoKHR, s_type), offset_of!(CopyMemoryToAccelerationStructureInfoKHR, p_next), offset_of!(CopyMemoryToAccelerationStructureInfoKHR, src), offset_of!(CopyMemoryToAccelerationStructureInfoKHR, dst), offset_of!(CopyMemoryToAccelerationStructureInfoKHR, mode));
    println!("RayTracingPipelineInterfaceCreateInfoKHR {} {} {} {} {} {}", size_of::<RayTracingPipelineInterfaceCreateInfoKHR>(), align_of::<RayTracingPipelineInterfaceCreateInfoKHR>(), offset_of!(RayTracingPipelineInterfaceCreateInfoKHR, s_type), offset_of!(RayTracingPipelineInterfaceCreateInfoKHR, p_next), offset_of!(RayTracingPipelineInterfaceCreateInfoKHR, max_pipeline_ray_payload_size), offset_of!(RayTracingPipelineInterfaceCreateInfoKHR, max_pipeline_ray_hit_attribute_size));
    println!("PipelineLibraryCreateInfoKHR {} {} {} {} {} {}", size_of::<PipelineLibraryCreateInfoKHR>(), align_of::<PipelineLibraryCreateInfoKHR>(), offset_of!(PipelineLibraryCreateInfoKHR, s_type), offset_of!(PipelineLibraryCreateInfoKHR, p_next), offset_of!(PipelineLibraryCreateInfoKHR, library_count), offset_of!(PipelineLibraryCreateInfoKHR, p_libraries));
    println!("PhysicalDeviceExtendedDynamicStateFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceExtendedDynamicStateFeaturesEXT>(), align_of::<PhysicalDeviceExtendedDynamicStateFeaturesEXT>(), offset_of!(PhysicalDeviceExtendedDynamicStateFeaturesEXT, s_type), offset_of!(PhysicalDeviceExtendedDynamicStateFeaturesEXT, p_next), offset_of!(PhysicalDeviceExtendedDynamicStateFeaturesEXT, extended_dynamic_state));
    println!("PhysicalDeviceExtendedDynamicState2FeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceExtendedDynamicState2FeaturesEXT>(), align_of::<PhysicalDeviceExtendedDynamicState2FeaturesEXT>(), offset_of!(PhysicalDeviceExtendedDynamicState2FeaturesEXT, s_type), offset_of!(PhysicalDeviceExtendedDynamicState2FeaturesEXT, p_next), offset_of!(PhysicalDeviceExtendedDynamicState2FeaturesEXT, extended_dynamic_state2), offset_of!(PhysicalDeviceExtendedDynamicState2FeaturesEXT, extended_dynamic_state2_logic_op), offset_of!(PhysicalDeviceExtendedDynamicState2FeaturesEXT, extended_dynamic_state2_patch_control_points));
    println!("PhysicalDeviceExtendedDynamicState3FeaturesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceExtendedDynamicState3FeaturesEXT>(), align_of::<PhysicalDeviceExtendedDynamicState3FeaturesEXT>(), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, s_type), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, p_next), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_tessellation_domain_origin), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_depth_clamp_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_polygon_mode), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_rasterization_samples), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_sample_mask), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_alpha_to_coverage_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_alpha_to_one_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_logic_op_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_color_blend_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_color_blend_equation), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_color_write_mask), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_rasterization_stream), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_conservative_rasterization_mode), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_extra_primitive_overestimation_size), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_depth_clip_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_sample_locations_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_color_blend_advanced), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_provoking_vertex_mode), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_line_rasterization_mode), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_line_stipple_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_depth_clip_negative_one_to_one), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_viewport_w_scaling_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_viewport_swizzle), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_coverage_to_color_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_coverage_to_color_location), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_coverage_modulation_mode), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_coverage_modulation_table_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_coverage_modulation_table), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_coverage_reduction_mode), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_representative_fragment_test_enable), offset_of!(PhysicalDeviceExtendedDynamicState3FeaturesEXT, extended_dynamic_state3_shading_rate_image_enable));
    println!("PhysicalDeviceExtendedDynamicState3PropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceExtendedDynamicState3PropertiesEXT>(), align_of::<PhysicalDeviceExtendedDynamicState3PropertiesEXT>(), offset_of!(PhysicalDeviceExtendedDynamicState3PropertiesEXT, s_type), offset_of!(PhysicalDeviceExtendedDynamicState3PropertiesEXT, p_next), offset_of!(PhysicalDeviceExtendedDynamicState3PropertiesEXT, dynamic_primitive_topology_unrestricted));
    println!("ColorBlendEquationEXT {} {} {} {} {} {} {} {}", size_of::<ColorBlendEquationEXT>(), align_of::<ColorBlendEquationEXT>(), offset_of!(ColorBlendEquationEXT, src_color_blend_factor), offset_of!(ColorBlendEquationEXT, dst_color_blend_factor), offset_of!(ColorBlendEquationEXT, color_blend_op), offset_of!(ColorBlendEquationEXT, src_alpha_blend_factor), offset_of!(ColorBlendEquationEXT, dst_alpha_blend_factor), offset_of!(ColorBlendEquationEXT, alpha_blend_op));
    println!("ColorBlendAdvancedEXT {} {} {} {} {} {} {}", size_of::<ColorBlendAdvancedEXT>(), align_of::<ColorBlendAdvancedEXT>(), offset_of!(ColorBlendAdvancedEXT, advanced_blend_op), offset_of!(ColorBlendAdvancedEXT, src_premultiplied), offset_of!(ColorBlendAdvancedEXT, dst_premultiplied), offset_of!(ColorBlendAdvancedEXT, blend_overlap), offset_of!(ColorBlendAdvancedEXT, clamp_results));
    println!("RenderPassTransformBeginInfoQCOM {} {} {} {} {}", size_of::<RenderPassTransformBeginInfoQCOM>(), align_of::<RenderPassTransformBeginInfoQCOM>(), offset_of!(RenderPassTransformBeginInfoQCOM, s_type), offset_of!(RenderPassTransformBeginInfoQCOM, p_next), offset_of!(RenderPassTransformBeginInfoQCOM, transform));
    println!("CopyCommandTransformInfoQCOM {} {} {} {} {}", size_of::<CopyCommandTransformInfoQCOM>(), align_of::<CopyCommandTransformInfoQCOM>(), offset_of!(CopyCommandTransformInfoQCOM, s_type), offset_of!(CopyCommandTransformInfoQCOM, p_next), offset_of!(CopyCommandTransformInfoQCOM, transform));
    println!("CommandBufferInheritanceRenderPassTransformInfoQCOM {} {} {} {} {} {}", size_of::<CommandBufferInheritanceRenderPassTransformInfoQCOM>(), align_of::<CommandBufferInheritanceRenderPassTransformInfoQCOM>(), offset_of!(CommandBufferInheritanceRenderPassTransformInfoQCOM, s_type), offset_of!(CommandBufferInheritanceRenderPassTransformInfoQCOM, p_next), offset_of!(CommandBufferInheritanceRenderPassTransformInfoQCOM, transform), offset_of!(CommandBufferInheritanceRenderPassTransformInfoQCOM, render_area));
    println!("PhysicalDevicePartitionedAccelerationStructureFeaturesNV {} {} {} {} {}", size_of::<PhysicalDevicePartitionedAccelerationStructureFeaturesNV>(), align_of::<PhysicalDevicePartitionedAccelerationStructureFeaturesNV>(), offset_of!(PhysicalDevicePartitionedAccelerationStructureFeaturesNV, s_type), offset_of!(PhysicalDevicePartitionedAccelerationStructureFeaturesNV, p_next), offset_of!(PhysicalDevicePartitionedAccelerationStructureFeaturesNV, partitioned_acceleration_structure));
    println!("PhysicalDevicePartitionedAccelerationStructurePropertiesNV {} {} {} {} {}", size_of::<PhysicalDevicePartitionedAccelerationStructurePropertiesNV>(), align_of::<PhysicalDevicePartitionedAccelerationStructurePropertiesNV>(), offset_of!(PhysicalDevicePartitionedAccelerationStructurePropertiesNV, s_type), offset_of!(PhysicalDevicePartitionedAccelerationStructurePropertiesNV, p_next), offset_of!(PhysicalDevicePartitionedAccelerationStructurePropertiesNV, max_partition_count));
    println!("BuildPartitionedAccelerationStructureIndirectCommandNV {} {} {} {} {}", size_of::<BuildPartitionedAccelerationStructureIndirectCommandNV>(), align_of::<BuildPartitionedAccelerationStructureIndirectCommandNV>(), offset_of!(BuildPartitionedAccelerationStructureIndirectCommandNV, op_type), offset_of!(BuildPartitionedAccelerationStructureIndirectCommandNV, arg_count), offset_of!(BuildPartitionedAccelerationStructureIndirectCommandNV, arg_data));
    println!("PartitionedAccelerationStructureFlagsNV {} {} {} {} {}", size_of::<PartitionedAccelerationStructureFlagsNV>(), align_of::<PartitionedAccelerationStructureFlagsNV>(), offset_of!(PartitionedAccelerationStructureFlagsNV, s_type), offset_of!(PartitionedAccelerationStructureFlagsNV, p_next), offset_of!(PartitionedAccelerationStructureFlagsNV, enable_partition_translation));
    println!("PartitionedAccelerationStructureWriteInstanceDataNV {} {} {} {} {} {} {} {} {} {} {}", size_of::<PartitionedAccelerationStructureWriteInstanceDataNV>(), align_of::<PartitionedAccelerationStructureWriteInstanceDataNV>(), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, transform), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, explicit_aabb), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, instance_id), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, instance_mask), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, instance_contribution_to_hit_group_index), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, instance_flags), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, instance_index), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, partition_index), offset_of!(PartitionedAccelerationStructureWriteInstanceDataNV, acceleration_structure));
    println!("PartitionedAccelerationStructureUpdateInstanceDataNV {} {} {} {} {}", size_of::<PartitionedAccelerationStructureUpdateInstanceDataNV>(), align_of::<PartitionedAccelerationStructureUpdateInstanceDataNV>(), offset_of!(PartitionedAccelerationStructureUpdateInstanceDataNV, instance_index), offset_of!(PartitionedAccelerationStructureUpdateInstanceDataNV, instance_contribution_to_hit_group_index), offset_of!(PartitionedAccelerationStructureUpdateInstanceDataNV, acceleration_structure));
    println!("PartitionedAccelerationStructureWritePartitionTranslationDataNV {} {} {} {}", size_of::<PartitionedAccelerationStructureWritePartitionTranslationDataNV>(), align_of::<PartitionedAccelerationStructureWritePartitionTranslationDataNV>(), offset_of!(PartitionedAccelerationStructureWritePartitionTranslationDataNV, partition_index), offset_of!(PartitionedAccelerationStructureWritePartitionTranslationDataNV, partition_translation));
    println!("WriteDescriptorSetPartitionedAccelerationStructureNV {} {} {} {} {} {}", size_of::<WriteDescriptorSetPartitionedAccelerationStructureNV>(), align_of::<WriteDescriptorSetPartitionedAccelerationStructureNV>(), offset_of!(WriteDescriptorSetPartitionedAccelerationStructureNV, s_type), offset_of!(WriteDescriptorSetPartitionedAccelerationStructureNV, p_next), offset_of!(WriteDescriptorSetPartitionedAccelerationStructureNV, acceleration_structure_count), offset_of!(WriteDescriptorSetPartitionedAccelerationStructureNV, p_acceleration_structures));
    println!("PartitionedAccelerationStructureInstancesInputNV {} {} {} {} {} {} {} {} {}", size_of::<PartitionedAccelerationStructureInstancesInputNV>(), align_of::<PartitionedAccelerationStructureInstancesInputNV>(), offset_of!(PartitionedAccelerationStructureInstancesInputNV, s_type), offset_of!(PartitionedAccelerationStructureInstancesInputNV, p_next), offset_of!(PartitionedAccelerationStructureInstancesInputNV, flags), offset_of!(PartitionedAccelerationStructureInstancesInputNV, instance_count), offset_of!(PartitionedAccelerationStructureInstancesInputNV, max_instance_per_partition_count), offset_of!(PartitionedAccelerationStructureInstancesInputNV, partition_count), offset_of!(PartitionedAccelerationStructureInstancesInputNV, max_instance_in_global_partition_count));
    println!("BuildPartitionedAccelerationStructureInfoNV {} {} {} {} {} {} {} {} {} {}", size_of::<BuildPartitionedAccelerationStructureInfoNV>(), align_of::<BuildPartitionedAccelerationStructureInfoNV>(), offset_of!(BuildPartitionedAccelerationStructureInfoNV, s_type), offset_of!(BuildPartitionedAccelerationStructureInfoNV, p_next), offset_of!(BuildPartitionedAccelerationStructureInfoNV, input), offset_of!(BuildPartitionedAccelerationStructureInfoNV, src_acceleration_structure_data), offset_of!(BuildPartitionedAccelerationStructureInfoNV, dst_acceleration_structure_data), offset_of!(BuildPartitionedAccelerationStructureInfoNV, scratch_data), offset_of!(BuildPartitionedAccelerationStructureInfoNV, src_infos), offset_of!(BuildPartitionedAccelerationStructureInfoNV, src_infos_count));
    println!("PhysicalDeviceDiagnosticsConfigFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceDiagnosticsConfigFeaturesNV>(), align_of::<PhysicalDeviceDiagnosticsConfigFeaturesNV>(), offset_of!(PhysicalDeviceDiagnosticsConfigFeaturesNV, s_type), offset_of!(PhysicalDeviceDiagnosticsConfigFeaturesNV, p_next), offset_of!(PhysicalDeviceDiagnosticsConfigFeaturesNV, diagnostics_config));
    println!("DeviceDiagnosticsConfigCreateInfoNV {} {} {} {} {}", size_of::<DeviceDiagnosticsConfigCreateInfoNV>(), align_of::<DeviceDiagnosticsConfigCreateInfoNV>(), offset_of!(DeviceDiagnosticsConfigCreateInfoNV, s_type), offset_of!(DeviceDiagnosticsConfigCreateInfoNV, p_next), offset_of!(DeviceDiagnosticsConfigCreateInfoNV, flags));
    println!("PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} {} {} {} {}", size_of::<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(), align_of::<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(), offset_of!(PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, s_type), offset_of!(PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, p_next), offset_of!(PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, shader_zero_initialize_workgroup_memory));
    println!("PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>(), align_of::<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>(), offset_of!(PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, shader_subgroup_uniform_control_flow));
    println!("PhysicalDeviceRobustness2FeaturesKHR {} {} {} {} {} {} {}", size_of::<PhysicalDeviceRobustness2FeaturesKHR>(), align_of::<PhysicalDeviceRobustness2FeaturesKHR>(), offset_of!(PhysicalDeviceRobustness2FeaturesKHR, s_type), offset_of!(PhysicalDeviceRobustness2FeaturesKHR, p_next), offset_of!(PhysicalDeviceRobustness2FeaturesKHR, robust_buffer_access2), offset_of!(PhysicalDeviceRobustness2FeaturesKHR, robust_image_access2), offset_of!(PhysicalDeviceRobustness2FeaturesKHR, null_descriptor));
    println!("PhysicalDeviceRobustness2PropertiesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceRobustness2PropertiesKHR>(), align_of::<PhysicalDeviceRobustness2PropertiesKHR>(), offset_of!(PhysicalDeviceRobustness2PropertiesKHR, s_type), offset_of!(PhysicalDeviceRobustness2PropertiesKHR, p_next), offset_of!(PhysicalDeviceRobustness2PropertiesKHR, robust_storage_buffer_access_size_alignment), offset_of!(PhysicalDeviceRobustness2PropertiesKHR, robust_uniform_buffer_access_size_alignment));
    println!("PhysicalDeviceImageRobustnessFeatures {} {} {} {} {}", size_of::<PhysicalDeviceImageRobustnessFeatures>(), align_of::<PhysicalDeviceImageRobustnessFeatures>(), offset_of!(PhysicalDeviceImageRobustnessFeatures, s_type), offset_of!(PhysicalDeviceImageRobustnessFeatures, p_next), offset_of!(PhysicalDeviceImageRobustnessFeatures, robust_image_access));
    println!("PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(), align_of::<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(), offset_of!(PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, s_type), offset_of!(PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, p_next), offset_of!(PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, workgroup_memory_explicit_layout), offset_of!(PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, workgroup_memory_explicit_layout_scalar_block_layout), offset_of!(PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, workgroup_memory_explicit_layout8_bit_access), offset_of!(PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, workgroup_memory_explicit_layout16_bit_access));
    println!("PhysicalDevice4444FormatsFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDevice4444FormatsFeaturesEXT>(), align_of::<PhysicalDevice4444FormatsFeaturesEXT>(), offset_of!(PhysicalDevice4444FormatsFeaturesEXT, s_type), offset_of!(PhysicalDevice4444FormatsFeaturesEXT, p_next), offset_of!(PhysicalDevice4444FormatsFeaturesEXT, format_a4r4g4b4), offset_of!(PhysicalDevice4444FormatsFeaturesEXT, format_a4b4g4r4));
    println!("PhysicalDeviceSubpassShadingFeaturesHUAWEI {} {} {} {} {}", size_of::<PhysicalDeviceSubpassShadingFeaturesHUAWEI>(), align_of::<PhysicalDeviceSubpassShadingFeaturesHUAWEI>(), offset_of!(PhysicalDeviceSubpassShadingFeaturesHUAWEI, s_type), offset_of!(PhysicalDeviceSubpassShadingFeaturesHUAWEI, p_next), offset_of!(PhysicalDeviceSubpassShadingFeaturesHUAWEI, subpass_shading));
    println!("PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {} {} {} {} {} {}", size_of::<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(), align_of::<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(), offset_of!(PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, s_type), offset_of!(PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, p_next), offset_of!(PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, clusterculling_shader), offset_of!(PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, multiview_cluster_culling_shader));
    println!("PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {} {} {} {} {}", size_of::<PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>(), align_of::<PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>(), offset_of!(PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, s_type), offset_of!(PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, p_next), offset_of!(PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, cluster_shading_rate));
    println!("BufferCopy2 {} {} {} {} {} {} {}", size_of::<BufferCopy2>(), align_of::<BufferCopy2>(), offset_of!(BufferCopy2, s_type), offset_of!(BufferCopy2, p_next), offset_of!(BufferCopy2, src_offset), offset_of!(BufferCopy2, dst_offset), offset_of!(BufferCopy2, size));
    println!("ImageCopy2 {} {} {} {} {} {} {} {} {}", size_of::<ImageCopy2>(), align_of::<ImageCopy2>(), offset_of!(ImageCopy2, s_type), offset_of!(ImageCopy2, p_next), offset_of!(ImageCopy2, src_subresource), offset_of!(ImageCopy2, src_offset), offset_of!(ImageCopy2, dst_subresource), offset_of!(ImageCopy2, dst_offset), offset_of!(ImageCopy2, extent));
    println!("ImageBlit2 {} {} {} {} {} {} {} {}", size_of::<ImageBlit2>(), align_of::<ImageBlit2>(), offset_of!(ImageBlit2, s_type), offset_of!(ImageBlit2, p_next), offset_of!(ImageBlit2, src_subresource), offset_of!(ImageBlit2, src_offsets), offset_of!(ImageBlit2, dst_subresource), offset_of!(ImageBlit2, dst_offsets));
    println!("BufferImageCopy2 {} {} {} {} {} {} {} {} {} {}", size_of::<BufferImageCopy2>(), align_of::<BufferImageCopy2>(), offset_of!(BufferImageCopy2, s_type), offset_of!(BufferImageCopy2, p_next), offset_of!(BufferImageCopy2, buffer_offset), offset_of!(BufferImageCopy2, buffer_row_length), offset_of!(BufferImageCopy2, buffer_image_height), offset_of!(BufferImageCopy2, image_subresource), offset_of!(BufferImageCopy2, image_offset), offset_of!(BufferImageCopy2, image_extent));
    println!("ImageResolve2 {} {} {} {} {} {} {} {} {}", size_of::<ImageResolve2>(), align_of::<ImageResolve2>(), offset_of!(ImageResolve2, s_type), offset_of!(ImageResolve2, p_next), offset_of!(ImageResolve2, src_subresource), offset_of!(ImageResolve2, src_offset), offset_of!(ImageResolve2, dst_subresource), offset_of!(ImageResolve2, dst_offset), offset_of!(ImageResolve2, extent));
    println!("CopyBufferInfo2 {} {} {} {} {} {} {} {}", size_of::<CopyBufferInfo2>(), align_of::<CopyBufferInfo2>(), offset_of!(CopyBufferInfo2, s_type), offset_of!(CopyBufferInfo2, p_next), offset_of!(CopyBufferInfo2, src_buffer), offset_of!(CopyBufferInfo2, dst_buffer), offset_of!(CopyBufferInfo2, region_count), offset_of!(CopyBufferInfo2, p_regions));
    println!("CopyImageInfo2 {} {} {} {} {} {} {} {} {} {}", size_of::<CopyImageInfo2>(), align_of::<CopyImageInfo2>(), offset_of!(CopyImageInfo2, s_type), offset_of!(CopyImageInfo2, p_next), offset_of!(CopyImageInfo2, src_image), offset_of!(CopyImageInfo2, src_image_layout), offset_of!(CopyImageInfo2, dst_image), offset_of!(CopyImageInfo2, dst_image_layout), offset_of!(CopyImageInfo2, region_count), offset_of!(CopyImageInfo2, p_regions));
    println!("BlitImageInfo2 {} {} {} {} {} {} {} {} {} {} {}", size_of::<BlitImageInfo2>(), align_of::<BlitImageInfo2>(), offset_of!(BlitImageInfo2, s_type), offset_of!(BlitImageInfo2, p_next), offset_of!(BlitImageInfo2, src_image), offset_of!(BlitImageInfo2, src_image_layout), offset_of!(BlitImageInfo2, dst_image), offset_of!(BlitImageInfo2, dst_image_layout), offset_of!(BlitImageInfo2, region_count), offset_of!(BlitImageInfo2, p_regions), offset_of!(BlitImageInfo2, filter));
    println!("CopyBufferToImageInfo2 {} {} {} {} {} {} {} {} {}", size_of::<CopyBufferToImageInfo2>(), align_of::<CopyBufferToImageInfo2>(), offset_of!(CopyBufferToImageInfo2, s_type), offset_of!(CopyBufferToImageInfo2, p_next), offset_of!(CopyBufferToImageInfo2, src_buffer), offset_of!(CopyBufferToImageInfo2, dst_image), offset_of!(CopyBufferToImageInfo2, dst_image_layout), offset_of!(CopyBufferToImageInfo2, region_count), offset_of!(CopyBufferToImageInfo2, p_regions));
    println!("CopyImageToBufferInfo2 {} {} {} {} {} {} {} {} {}", size_of::<CopyImageToBufferInfo2>(), align_of::<CopyImageToBufferInfo2>(), offset_of!(CopyImageToBufferInfo2, s_type), offset_of!(CopyImageToBufferInfo2, p_next), offset_of!(CopyImageToBufferInfo2, src_image), offset_of!(CopyImageToBufferInfo2, src_image_layout), offset_of!(CopyImageToBufferInfo2, dst_buffer), offset_of!(CopyImageToBufferInfo2, region_count), offset_of!(CopyImageToBufferInfo2, p_regions));
    println!("ResolveImageInfo2 {} {} {} {} {} {} {} {} {} {}", size_of::<ResolveImageInfo2>(), align_of::<ResolveImageInfo2>(), offset_of!(ResolveImageInfo2, s_type), offset_of!(ResolveImageInfo2, p_next), offset_of!(ResolveImageInfo2, src_image), offset_of!(ResolveImageInfo2, src_image_layout), offset_of!(ResolveImageInfo2, dst_image), offset_of!(ResolveImageInfo2, dst_image_layout), offset_of!(ResolveImageInfo2, region_count), offset_of!(ResolveImageInfo2, p_regions));
    println!("PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(), align_of::<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(), offset_of!(PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, shader_image_int64_atomics), offset_of!(PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, sparse_image_int64_atomics));
    println!("FragmentShadingRateAttachmentInfoKHR {} {} {} {} {} {}", size_of::<FragmentShadingRateAttachmentInfoKHR>(), align_of::<FragmentShadingRateAttachmentInfoKHR>(), offset_of!(FragmentShadingRateAttachmentInfoKHR, s_type), offset_of!(FragmentShadingRateAttachmentInfoKHR, p_next), offset_of!(FragmentShadingRateAttachmentInfoKHR, p_fragment_shading_rate_attachment), offset_of!(FragmentShadingRateAttachmentInfoKHR, shading_rate_attachment_texel_size));
    println!("PipelineFragmentShadingRateStateCreateInfoKHR {} {} {} {} {} {}", size_of::<PipelineFragmentShadingRateStateCreateInfoKHR>(), align_of::<PipelineFragmentShadingRateStateCreateInfoKHR>(), offset_of!(PipelineFragmentShadingRateStateCreateInfoKHR, s_type), offset_of!(PipelineFragmentShadingRateStateCreateInfoKHR, p_next), offset_of!(PipelineFragmentShadingRateStateCreateInfoKHR, fragment_size), offset_of!(PipelineFragmentShadingRateStateCreateInfoKHR, combiner_ops));
    println!("PhysicalDeviceFragmentShadingRateFeaturesKHR {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShadingRateFeaturesKHR>(), align_of::<PhysicalDeviceFragmentShadingRateFeaturesKHR>(), offset_of!(PhysicalDeviceFragmentShadingRateFeaturesKHR, s_type), offset_of!(PhysicalDeviceFragmentShadingRateFeaturesKHR, p_next), offset_of!(PhysicalDeviceFragmentShadingRateFeaturesKHR, pipeline_fragment_shading_rate), offset_of!(PhysicalDeviceFragmentShadingRateFeaturesKHR, primitive_fragment_shading_rate), offset_of!(PhysicalDeviceFragmentShadingRateFeaturesKHR, attachment_fragment_shading_rate));
    println!("PhysicalDeviceFragmentShadingRatePropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShadingRatePropertiesKHR>(), align_of::<PhysicalDeviceFragmentShadingRatePropertiesKHR>(), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, s_type), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, p_next), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, min_fragment_shading_rate_attachment_texel_size), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, max_fragment_shading_rate_attachment_texel_size), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, max_fragment_shading_rate_attachment_texel_size_aspect_ratio), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, primitive_fragment_shading_rate_with_multiple_viewports), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, layered_shading_rate_attachments), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_non_trivial_combiner_ops), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, max_fragment_size), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, max_fragment_size_aspect_ratio), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, max_fragment_shading_rate_coverage_samples), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, max_fragment_shading_rate_rasterization_samples), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_with_shader_depth_stencil_writes), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_with_sample_mask), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_with_shader_sample_mask), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_with_conservative_rasterization), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_with_fragment_shader_interlock), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_with_custom_sample_locations), offset_of!(PhysicalDeviceFragmentShadingRatePropertiesKHR, fragment_shading_rate_strict_multiply_combiner));
    println!("PhysicalDeviceFragmentShadingRateKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShadingRateKHR>(), align_of::<PhysicalDeviceFragmentShadingRateKHR>(), offset_of!(PhysicalDeviceFragmentShadingRateKHR, s_type), offset_of!(PhysicalDeviceFragmentShadingRateKHR, p_next), offset_of!(PhysicalDeviceFragmentShadingRateKHR, sample_counts), offset_of!(PhysicalDeviceFragmentShadingRateKHR, fragment_size));
    println!("PhysicalDeviceShaderTerminateInvocationFeatures {} {} {} {} {}", size_of::<PhysicalDeviceShaderTerminateInvocationFeatures>(), align_of::<PhysicalDeviceShaderTerminateInvocationFeatures>(), offset_of!(PhysicalDeviceShaderTerminateInvocationFeatures, s_type), offset_of!(PhysicalDeviceShaderTerminateInvocationFeatures, p_next), offset_of!(PhysicalDeviceShaderTerminateInvocationFeatures, shader_terminate_invocation));
    println!("PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(), align_of::<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(), offset_of!(PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, s_type), offset_of!(PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, p_next), offset_of!(PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, fragment_shading_rate_enums), offset_of!(PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, supersample_fragment_shading_rates), offset_of!(PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, no_invocation_fragment_shading_rates));
    println!("PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>(), align_of::<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>(), offset_of!(PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, s_type), offset_of!(PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, p_next), offset_of!(PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, max_fragment_shading_rate_invocation_count));
    println!("PipelineFragmentShadingRateEnumStateCreateInfoNV {} {} {} {} {} {} {}", size_of::<PipelineFragmentShadingRateEnumStateCreateInfoNV>(), align_of::<PipelineFragmentShadingRateEnumStateCreateInfoNV>(), offset_of!(PipelineFragmentShadingRateEnumStateCreateInfoNV, s_type), offset_of!(PipelineFragmentShadingRateEnumStateCreateInfoNV, p_next), offset_of!(PipelineFragmentShadingRateEnumStateCreateInfoNV, shading_rate_type), offset_of!(PipelineFragmentShadingRateEnumStateCreateInfoNV, shading_rate), offset_of!(PipelineFragmentShadingRateEnumStateCreateInfoNV, combiner_ops));
    println!("AccelerationStructureBuildSizesInfoKHR {} {} {} {} {} {} {}", size_of::<AccelerationStructureBuildSizesInfoKHR>(), align_of::<AccelerationStructureBuildSizesInfoKHR>(), offset_of!(AccelerationStructureBuildSizesInfoKHR, s_type), offset_of!(AccelerationStructureBuildSizesInfoKHR, p_next), offset_of!(AccelerationStructureBuildSizesInfoKHR, acceleration_structure_size), offset_of!(AccelerationStructureBuildSizesInfoKHR, update_scratch_size), offset_of!(AccelerationStructureBuildSizesInfoKHR, build_scratch_size));
    println!("PhysicalDeviceImage2DViewOf3DFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceImage2DViewOf3DFeaturesEXT>(), align_of::<PhysicalDeviceImage2DViewOf3DFeaturesEXT>(), offset_of!(PhysicalDeviceImage2DViewOf3DFeaturesEXT, s_type), offset_of!(PhysicalDeviceImage2DViewOf3DFeaturesEXT, p_next), offset_of!(PhysicalDeviceImage2DViewOf3DFeaturesEXT, image2_d_view_of3_d), offset_of!(PhysicalDeviceImage2DViewOf3DFeaturesEXT, sampler2_d_view_of3_d));
    println!("PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>(), align_of::<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>(), offset_of!(PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, s_type), offset_of!(PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, p_next), offset_of!(PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, image_sliced_view_of3_d));
    println!("PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>(), align_of::<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>(), offset_of!(PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, s_type), offset_of!(PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, p_next), offset_of!(PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, attachment_feedback_loop_dynamic_state));
    println!("PhysicalDeviceLegacyVertexAttributesFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceLegacyVertexAttributesFeaturesEXT>(), align_of::<PhysicalDeviceLegacyVertexAttributesFeaturesEXT>(), offset_of!(PhysicalDeviceLegacyVertexAttributesFeaturesEXT, s_type), offset_of!(PhysicalDeviceLegacyVertexAttributesFeaturesEXT, p_next), offset_of!(PhysicalDeviceLegacyVertexAttributesFeaturesEXT, legacy_vertex_attributes));
    println!("PhysicalDeviceLegacyVertexAttributesPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceLegacyVertexAttributesPropertiesEXT>(), align_of::<PhysicalDeviceLegacyVertexAttributesPropertiesEXT>(), offset_of!(PhysicalDeviceLegacyVertexAttributesPropertiesEXT, s_type), offset_of!(PhysicalDeviceLegacyVertexAttributesPropertiesEXT, p_next), offset_of!(PhysicalDeviceLegacyVertexAttributesPropertiesEXT, native_unaligned_performance));
    println!("PhysicalDeviceMutableDescriptorTypeFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMutableDescriptorTypeFeaturesEXT>(), align_of::<PhysicalDeviceMutableDescriptorTypeFeaturesEXT>(), offset_of!(PhysicalDeviceMutableDescriptorTypeFeaturesEXT, s_type), offset_of!(PhysicalDeviceMutableDescriptorTypeFeaturesEXT, p_next), offset_of!(PhysicalDeviceMutableDescriptorTypeFeaturesEXT, mutable_descriptor_type));
    println!("MutableDescriptorTypeListEXT {} {} {} {}", size_of::<MutableDescriptorTypeListEXT>(), align_of::<MutableDescriptorTypeListEXT>(), offset_of!(MutableDescriptorTypeListEXT, descriptor_type_count), offset_of!(MutableDescriptorTypeListEXT, p_descriptor_types));
    println!("MutableDescriptorTypeCreateInfoEXT {} {} {} {} {} {}", size_of::<MutableDescriptorTypeCreateInfoEXT>(), align_of::<MutableDescriptorTypeCreateInfoEXT>(), offset_of!(MutableDescriptorTypeCreateInfoEXT, s_type), offset_of!(MutableDescriptorTypeCreateInfoEXT, p_next), offset_of!(MutableDescriptorTypeCreateInfoEXT, mutable_descriptor_type_list_count), offset_of!(MutableDescriptorTypeCreateInfoEXT, p_mutable_descriptor_type_lists));
    println!("PhysicalDeviceDepthClipControlFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDepthClipControlFeaturesEXT>(), align_of::<PhysicalDeviceDepthClipControlFeaturesEXT>(), offset_of!(PhysicalDeviceDepthClipControlFeaturesEXT, s_type), offset_of!(PhysicalDeviceDepthClipControlFeaturesEXT, p_next), offset_of!(PhysicalDeviceDepthClipControlFeaturesEXT, depth_clip_control));
    println!("PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>(), align_of::<PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>(), offset_of!(PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, s_type), offset_of!(PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, p_next), offset_of!(PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, zero_initialize_device_memory));
    println!("BeginCustomResolveInfoEXT {} {} {} {}", size_of::<BeginCustomResolveInfoEXT>(), align_of::<BeginCustomResolveInfoEXT>(), offset_of!(BeginCustomResolveInfoEXT, s_type), offset_of!(BeginCustomResolveInfoEXT, p_next));
    println!("PhysicalDeviceCustomResolveFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceCustomResolveFeaturesEXT>(), align_of::<PhysicalDeviceCustomResolveFeaturesEXT>(), offset_of!(PhysicalDeviceCustomResolveFeaturesEXT, s_type), offset_of!(PhysicalDeviceCustomResolveFeaturesEXT, p_next), offset_of!(PhysicalDeviceCustomResolveFeaturesEXT, custom_resolve));
    println!("CustomResolveCreateInfoEXT {} {} {} {} {} {} {} {} {}", size_of::<CustomResolveCreateInfoEXT>(), align_of::<CustomResolveCreateInfoEXT>(), offset_of!(CustomResolveCreateInfoEXT, s_type), offset_of!(CustomResolveCreateInfoEXT, p_next), offset_of!(CustomResolveCreateInfoEXT, custom_resolve), offset_of!(CustomResolveCreateInfoEXT, color_attachment_count), offset_of!(CustomResolveCreateInfoEXT, p_color_attachment_formats), offset_of!(CustomResolveCreateInfoEXT, depth_attachment_format), offset_of!(CustomResolveCreateInfoEXT, stencil_attachment_format));
    println!("PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>(), align_of::<PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>(), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, s_type), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, p_next), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, device_generated_commands), offset_of!(PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, dynamic_generated_pipeline_layout));
    println!("PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>(), align_of::<PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>(), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, s_type), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, p_next), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, max_indirect_pipeline_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, max_indirect_shader_object_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, max_indirect_sequence_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, max_indirect_commands_token_count), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, max_indirect_commands_token_offset), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, max_indirect_commands_indirect_stride), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, supported_indirect_commands_input_modes), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, supported_indirect_commands_shader_stages), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, supported_indirect_commands_shader_stages_pipeline_binding), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, supported_indirect_commands_shader_stages_shader_binding), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, device_generated_commands_transform_feedback), offset_of!(PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, device_generated_commands_multi_draw_indirect_count));
    println!("GeneratedCommandsPipelineInfoEXT {} {} {} {} {}", size_of::<GeneratedCommandsPipelineInfoEXT>(), align_of::<GeneratedCommandsPipelineInfoEXT>(), offset_of!(GeneratedCommandsPipelineInfoEXT, s_type), offset_of!(GeneratedCommandsPipelineInfoEXT, p_next), offset_of!(GeneratedCommandsPipelineInfoEXT, pipeline));
    println!("GeneratedCommandsShaderInfoEXT {} {} {} {} {} {}", size_of::<GeneratedCommandsShaderInfoEXT>(), align_of::<GeneratedCommandsShaderInfoEXT>(), offset_of!(GeneratedCommandsShaderInfoEXT, s_type), offset_of!(GeneratedCommandsShaderInfoEXT, p_next), offset_of!(GeneratedCommandsShaderInfoEXT, shader_count), offset_of!(GeneratedCommandsShaderInfoEXT, p_shaders));
    println!("GeneratedCommandsMemoryRequirementsInfoEXT {} {} {} {} {} {} {} {}", size_of::<GeneratedCommandsMemoryRequirementsInfoEXT>(), align_of::<GeneratedCommandsMemoryRequirementsInfoEXT>(), offset_of!(GeneratedCommandsMemoryRequirementsInfoEXT, s_type), offset_of!(GeneratedCommandsMemoryRequirementsInfoEXT, p_next), offset_of!(GeneratedCommandsMemoryRequirementsInfoEXT, indirect_execution_set), offset_of!(GeneratedCommandsMemoryRequirementsInfoEXT, indirect_commands_layout), offset_of!(GeneratedCommandsMemoryRequirementsInfoEXT, max_sequence_count), offset_of!(GeneratedCommandsMemoryRequirementsInfoEXT, max_draw_count));
    println!("IndirectExecutionSetPipelineInfoEXT {} {} {} {} {} {}", size_of::<IndirectExecutionSetPipelineInfoEXT>(), align_of::<IndirectExecutionSetPipelineInfoEXT>(), offset_of!(IndirectExecutionSetPipelineInfoEXT, s_type), offset_of!(IndirectExecutionSetPipelineInfoEXT, p_next), offset_of!(IndirectExecutionSetPipelineInfoEXT, initial_pipeline), offset_of!(IndirectExecutionSetPipelineInfoEXT, max_pipeline_count));
    println!("IndirectExecutionSetShaderLayoutInfoEXT {} {} {} {} {} {}", size_of::<IndirectExecutionSetShaderLayoutInfoEXT>(), align_of::<IndirectExecutionSetShaderLayoutInfoEXT>(), offset_of!(IndirectExecutionSetShaderLayoutInfoEXT, s_type), offset_of!(IndirectExecutionSetShaderLayoutInfoEXT, p_next), offset_of!(IndirectExecutionSetShaderLayoutInfoEXT, set_layout_count), offset_of!(IndirectExecutionSetShaderLayoutInfoEXT, p_set_layouts));
    println!("IndirectExecutionSetShaderInfoEXT {} {} {} {} {} {} {} {} {} {}", size_of::<IndirectExecutionSetShaderInfoEXT>(), align_of::<IndirectExecutionSetShaderInfoEXT>(), offset_of!(IndirectExecutionSetShaderInfoEXT, s_type), offset_of!(IndirectExecutionSetShaderInfoEXT, p_next), offset_of!(IndirectExecutionSetShaderInfoEXT, shader_count), offset_of!(IndirectExecutionSetShaderInfoEXT, p_initial_shaders), offset_of!(IndirectExecutionSetShaderInfoEXT, p_set_layout_infos), offset_of!(IndirectExecutionSetShaderInfoEXT, max_shader_count), offset_of!(IndirectExecutionSetShaderInfoEXT, push_constant_range_count), offset_of!(IndirectExecutionSetShaderInfoEXT, p_push_constant_ranges));
    println!("IndirectExecutionSetInfoEXT {} {} {} {}", size_of::<IndirectExecutionSetInfoEXT>(), align_of::<IndirectExecutionSetInfoEXT>(), offset_of!(IndirectExecutionSetInfoEXT, p_pipeline_info), offset_of!(IndirectExecutionSetInfoEXT, p_shader_info));
    println!("IndirectExecutionSetCreateInfoEXT {} {} {} {} {}", size_of::<IndirectExecutionSetCreateInfoEXT>(), align_of::<IndirectExecutionSetCreateInfoEXT>(), offset_of!(IndirectExecutionSetCreateInfoEXT, s_type), offset_of!(IndirectExecutionSetCreateInfoEXT, p_next), offset_of!(IndirectExecutionSetCreateInfoEXT, info));
    println!("GeneratedCommandsInfoEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<GeneratedCommandsInfoEXT>(), align_of::<GeneratedCommandsInfoEXT>(), offset_of!(GeneratedCommandsInfoEXT, s_type), offset_of!(GeneratedCommandsInfoEXT, p_next), offset_of!(GeneratedCommandsInfoEXT, shader_stages), offset_of!(GeneratedCommandsInfoEXT, indirect_execution_set), offset_of!(GeneratedCommandsInfoEXT, indirect_commands_layout), offset_of!(GeneratedCommandsInfoEXT, indirect_address), offset_of!(GeneratedCommandsInfoEXT, indirect_address_size), offset_of!(GeneratedCommandsInfoEXT, preprocess_address), offset_of!(GeneratedCommandsInfoEXT, preprocess_size), offset_of!(GeneratedCommandsInfoEXT, max_sequence_count), offset_of!(GeneratedCommandsInfoEXT, sequence_count_address), offset_of!(GeneratedCommandsInfoEXT, max_draw_count));
    println!("WriteIndirectExecutionSetPipelineEXT {} {} {} {} {} {}", size_of::<WriteIndirectExecutionSetPipelineEXT>(), align_of::<WriteIndirectExecutionSetPipelineEXT>(), offset_of!(WriteIndirectExecutionSetPipelineEXT, s_type), offset_of!(WriteIndirectExecutionSetPipelineEXT, p_next), offset_of!(WriteIndirectExecutionSetPipelineEXT, index), offset_of!(WriteIndirectExecutionSetPipelineEXT, pipeline));
    println!("WriteIndirectExecutionSetShaderEXT {} {} {} {} {} {}", size_of::<WriteIndirectExecutionSetShaderEXT>(), align_of::<WriteIndirectExecutionSetShaderEXT>(), offset_of!(WriteIndirectExecutionSetShaderEXT, s_type), offset_of!(WriteIndirectExecutionSetShaderEXT, p_next), offset_of!(WriteIndirectExecutionSetShaderEXT, index), offset_of!(WriteIndirectExecutionSetShaderEXT, shader));
    println!("IndirectCommandsLayoutCreateInfoEXT {} {} {} {} {} {} {} {} {} {}", size_of::<IndirectCommandsLayoutCreateInfoEXT>(), align_of::<IndirectCommandsLayoutCreateInfoEXT>(), offset_of!(IndirectCommandsLayoutCreateInfoEXT, s_type), offset_of!(IndirectCommandsLayoutCreateInfoEXT, p_next), offset_of!(IndirectCommandsLayoutCreateInfoEXT, flags), offset_of!(IndirectCommandsLayoutCreateInfoEXT, shader_stages), offset_of!(IndirectCommandsLayoutCreateInfoEXT, indirect_stride), offset_of!(IndirectCommandsLayoutCreateInfoEXT, pipeline_layout), offset_of!(IndirectCommandsLayoutCreateInfoEXT, token_count), offset_of!(IndirectCommandsLayoutCreateInfoEXT, p_tokens));
    println!("IndirectCommandsLayoutTokenEXT {} {} {} {} {} {}", size_of::<IndirectCommandsLayoutTokenEXT>(), align_of::<IndirectCommandsLayoutTokenEXT>(), offset_of!(IndirectCommandsLayoutTokenEXT, s_type), offset_of!(IndirectCommandsLayoutTokenEXT, p_next), offset_of!(IndirectCommandsLayoutTokenEXT, data), offset_of!(IndirectCommandsLayoutTokenEXT, offset));
    println!("DrawIndirectCountIndirectCommandEXT {} {} {} {} {}", size_of::<DrawIndirectCountIndirectCommandEXT>(), align_of::<DrawIndirectCountIndirectCommandEXT>(), offset_of!(DrawIndirectCountIndirectCommandEXT, buffer_address), offset_of!(DrawIndirectCountIndirectCommandEXT, stride), offset_of!(DrawIndirectCountIndirectCommandEXT, command_count));
    println!("IndirectCommandsVertexBufferTokenEXT {} {} {}", size_of::<IndirectCommandsVertexBufferTokenEXT>(), align_of::<IndirectCommandsVertexBufferTokenEXT>(), offset_of!(IndirectCommandsVertexBufferTokenEXT, vertex_binding_unit));
    println!("BindVertexBufferIndirectCommandEXT {} {} {} {} {}", size_of::<BindVertexBufferIndirectCommandEXT>(), align_of::<BindVertexBufferIndirectCommandEXT>(), offset_of!(BindVertexBufferIndirectCommandEXT, buffer_address), offset_of!(BindVertexBufferIndirectCommandEXT, size), offset_of!(BindVertexBufferIndirectCommandEXT, stride));
    println!("IndirectCommandsIndexBufferTokenEXT {} {} {}", size_of::<IndirectCommandsIndexBufferTokenEXT>(), align_of::<IndirectCommandsIndexBufferTokenEXT>(), offset_of!(IndirectCommandsIndexBufferTokenEXT, mode));
    println!("BindIndexBufferIndirectCommandEXT {} {} {} {} {}", size_of::<BindIndexBufferIndirectCommandEXT>(), align_of::<BindIndexBufferIndirectCommandEXT>(), offset_of!(BindIndexBufferIndirectCommandEXT, buffer_address), offset_of!(BindIndexBufferIndirectCommandEXT, size), offset_of!(BindIndexBufferIndirectCommandEXT, index_type));
    println!("IndirectCommandsPushConstantTokenEXT {} {} {}", size_of::<IndirectCommandsPushConstantTokenEXT>(), align_of::<IndirectCommandsPushConstantTokenEXT>(), offset_of!(IndirectCommandsPushConstantTokenEXT, update_range));
    println!("IndirectCommandsExecutionSetTokenEXT {} {} {}", size_of::<IndirectCommandsExecutionSetTokenEXT>(), align_of::<IndirectCommandsExecutionSetTokenEXT>(), offset_of!(IndirectCommandsExecutionSetTokenEXT, shader_stages));
    println!("IndirectCommandsTokenDataEXT {} {} {} {} {} {}", size_of::<IndirectCommandsTokenDataEXT>(), align_of::<IndirectCommandsTokenDataEXT>(), offset_of!(IndirectCommandsTokenDataEXT, p_push_constant), offset_of!(IndirectCommandsTokenDataEXT, p_vertex_buffer), offset_of!(IndirectCommandsTokenDataEXT, p_index_buffer), offset_of!(IndirectCommandsTokenDataEXT, p_execution_set));
    println!("PipelineViewportDepthClipControlCreateInfoEXT {} {} {} {} {}", size_of::<PipelineViewportDepthClipControlCreateInfoEXT>(), align_of::<PipelineViewportDepthClipControlCreateInfoEXT>(), offset_of!(PipelineViewportDepthClipControlCreateInfoEXT, s_type), offset_of!(PipelineViewportDepthClipControlCreateInfoEXT, p_next), offset_of!(PipelineViewportDepthClipControlCreateInfoEXT, negative_one_to_one));
    println!("PhysicalDeviceDepthClampControlFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDepthClampControlFeaturesEXT>(), align_of::<PhysicalDeviceDepthClampControlFeaturesEXT>(), offset_of!(PhysicalDeviceDepthClampControlFeaturesEXT, s_type), offset_of!(PhysicalDeviceDepthClampControlFeaturesEXT, p_next), offset_of!(PhysicalDeviceDepthClampControlFeaturesEXT, depth_clamp_control));
    println!("PipelineViewportDepthClampControlCreateInfoEXT {} {} {} {} {} {}", size_of::<PipelineViewportDepthClampControlCreateInfoEXT>(), align_of::<PipelineViewportDepthClampControlCreateInfoEXT>(), offset_of!(PipelineViewportDepthClampControlCreateInfoEXT, s_type), offset_of!(PipelineViewportDepthClampControlCreateInfoEXT, p_next), offset_of!(PipelineViewportDepthClampControlCreateInfoEXT, depth_clamp_mode), offset_of!(PipelineViewportDepthClampControlCreateInfoEXT, p_depth_clamp_range));
    println!("PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceVertexInputDynamicStateFeaturesEXT>(), align_of::<PhysicalDeviceVertexInputDynamicStateFeaturesEXT>(), offset_of!(PhysicalDeviceVertexInputDynamicStateFeaturesEXT, s_type), offset_of!(PhysicalDeviceVertexInputDynamicStateFeaturesEXT, p_next), offset_of!(PhysicalDeviceVertexInputDynamicStateFeaturesEXT, vertex_input_dynamic_state));
    println!("PhysicalDeviceExternalMemoryRDMAFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceExternalMemoryRDMAFeaturesNV>(), align_of::<PhysicalDeviceExternalMemoryRDMAFeaturesNV>(), offset_of!(PhysicalDeviceExternalMemoryRDMAFeaturesNV, s_type), offset_of!(PhysicalDeviceExternalMemoryRDMAFeaturesNV, p_next), offset_of!(PhysicalDeviceExternalMemoryRDMAFeaturesNV, external_memory_rdma));
    println!("PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>(), align_of::<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>(), offset_of!(PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, shader_relaxed_extended_instruction));
    println!("VertexInputBindingDescription2EXT {} {} {} {} {} {} {} {}", size_of::<VertexInputBindingDescription2EXT>(), align_of::<VertexInputBindingDescription2EXT>(), offset_of!(VertexInputBindingDescription2EXT, s_type), offset_of!(VertexInputBindingDescription2EXT, p_next), offset_of!(VertexInputBindingDescription2EXT, binding), offset_of!(VertexInputBindingDescription2EXT, stride), offset_of!(VertexInputBindingDescription2EXT, input_rate), offset_of!(VertexInputBindingDescription2EXT, divisor));
    println!("VertexInputAttributeDescription2EXT {} {} {} {} {} {} {} {}", size_of::<VertexInputAttributeDescription2EXT>(), align_of::<VertexInputAttributeDescription2EXT>(), offset_of!(VertexInputAttributeDescription2EXT, s_type), offset_of!(VertexInputAttributeDescription2EXT, p_next), offset_of!(VertexInputAttributeDescription2EXT, location), offset_of!(VertexInputAttributeDescription2EXT, binding), offset_of!(VertexInputAttributeDescription2EXT, format), offset_of!(VertexInputAttributeDescription2EXT, offset));
    println!("PhysicalDeviceColorWriteEnableFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceColorWriteEnableFeaturesEXT>(), align_of::<PhysicalDeviceColorWriteEnableFeaturesEXT>(), offset_of!(PhysicalDeviceColorWriteEnableFeaturesEXT, s_type), offset_of!(PhysicalDeviceColorWriteEnableFeaturesEXT, p_next), offset_of!(PhysicalDeviceColorWriteEnableFeaturesEXT, color_write_enable));
    println!("PipelineColorWriteCreateInfoEXT {} {} {} {} {} {}", size_of::<PipelineColorWriteCreateInfoEXT>(), align_of::<PipelineColorWriteCreateInfoEXT>(), offset_of!(PipelineColorWriteCreateInfoEXT, s_type), offset_of!(PipelineColorWriteCreateInfoEXT, p_next), offset_of!(PipelineColorWriteCreateInfoEXT, attachment_count), offset_of!(PipelineColorWriteCreateInfoEXT, p_color_write_enables));
    println!("MemoryBarrier2 {} {} {} {} {} {} {} {}", size_of::<MemoryBarrier2>(), align_of::<MemoryBarrier2>(), offset_of!(MemoryBarrier2, s_type), offset_of!(MemoryBarrier2, p_next), offset_of!(MemoryBarrier2, src_stage_mask), offset_of!(MemoryBarrier2, src_access_mask), offset_of!(MemoryBarrier2, dst_stage_mask), offset_of!(MemoryBarrier2, dst_access_mask));
    println!("ImageMemoryBarrier2 {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ImageMemoryBarrier2>(), align_of::<ImageMemoryBarrier2>(), offset_of!(ImageMemoryBarrier2, s_type), offset_of!(ImageMemoryBarrier2, p_next), offset_of!(ImageMemoryBarrier2, src_stage_mask), offset_of!(ImageMemoryBarrier2, src_access_mask), offset_of!(ImageMemoryBarrier2, dst_stage_mask), offset_of!(ImageMemoryBarrier2, dst_access_mask), offset_of!(ImageMemoryBarrier2, old_layout), offset_of!(ImageMemoryBarrier2, new_layout), offset_of!(ImageMemoryBarrier2, src_queue_family_index), offset_of!(ImageMemoryBarrier2, dst_queue_family_index), offset_of!(ImageMemoryBarrier2, image), offset_of!(ImageMemoryBarrier2, subresource_range));
    println!("BufferMemoryBarrier2 {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<BufferMemoryBarrier2>(), align_of::<BufferMemoryBarrier2>(), offset_of!(BufferMemoryBarrier2, s_type), offset_of!(BufferMemoryBarrier2, p_next), offset_of!(BufferMemoryBarrier2, src_stage_mask), offset_of!(BufferMemoryBarrier2, src_access_mask), offset_of!(BufferMemoryBarrier2, dst_stage_mask), offset_of!(BufferMemoryBarrier2, dst_access_mask), offset_of!(BufferMemoryBarrier2, src_queue_family_index), offset_of!(BufferMemoryBarrier2, dst_queue_family_index), offset_of!(BufferMemoryBarrier2, buffer), offset_of!(BufferMemoryBarrier2, offset), offset_of!(BufferMemoryBarrier2, size));
    println!("MemoryBarrierAccessFlags3KHR {} {} {} {} {} {}", size_of::<MemoryBarrierAccessFlags3KHR>(), align_of::<MemoryBarrierAccessFlags3KHR>(), offset_of!(MemoryBarrierAccessFlags3KHR, s_type), offset_of!(MemoryBarrierAccessFlags3KHR, p_next), offset_of!(MemoryBarrierAccessFlags3KHR, src_access_mask3), offset_of!(MemoryBarrierAccessFlags3KHR, dst_access_mask3));
    println!("DependencyInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<DependencyInfo>(), align_of::<DependencyInfo>(), offset_of!(DependencyInfo, s_type), offset_of!(DependencyInfo, p_next), offset_of!(DependencyInfo, dependency_flags), offset_of!(DependencyInfo, memory_barrier_count), offset_of!(DependencyInfo, p_memory_barriers), offset_of!(DependencyInfo, buffer_memory_barrier_count), offset_of!(DependencyInfo, p_buffer_memory_barriers), offset_of!(DependencyInfo, image_memory_barrier_count), offset_of!(DependencyInfo, p_image_memory_barriers));
    println!("SemaphoreSubmitInfo {} {} {} {} {} {} {} {}", size_of::<SemaphoreSubmitInfo>(), align_of::<SemaphoreSubmitInfo>(), offset_of!(SemaphoreSubmitInfo, s_type), offset_of!(SemaphoreSubmitInfo, p_next), offset_of!(SemaphoreSubmitInfo, semaphore), offset_of!(SemaphoreSubmitInfo, value), offset_of!(SemaphoreSubmitInfo, stage_mask), offset_of!(SemaphoreSubmitInfo, device_index));
    println!("CommandBufferSubmitInfo {} {} {} {} {} {}", size_of::<CommandBufferSubmitInfo>(), align_of::<CommandBufferSubmitInfo>(), offset_of!(CommandBufferSubmitInfo, s_type), offset_of!(CommandBufferSubmitInfo, p_next), offset_of!(CommandBufferSubmitInfo, command_buffer), offset_of!(CommandBufferSubmitInfo, device_mask));
    println!("SubmitInfo2 {} {} {} {} {} {} {} {} {} {} {}", size_of::<SubmitInfo2>(), align_of::<SubmitInfo2>(), offset_of!(SubmitInfo2, s_type), offset_of!(SubmitInfo2, p_next), offset_of!(SubmitInfo2, flags), offset_of!(SubmitInfo2, wait_semaphore_info_count), offset_of!(SubmitInfo2, p_wait_semaphore_infos), offset_of!(SubmitInfo2, command_buffer_info_count), offset_of!(SubmitInfo2, p_command_buffer_infos), offset_of!(SubmitInfo2, signal_semaphore_info_count), offset_of!(SubmitInfo2, p_signal_semaphore_infos));
    println!("QueueFamilyCheckpointProperties2NV {} {} {} {} {}", size_of::<QueueFamilyCheckpointProperties2NV>(), align_of::<QueueFamilyCheckpointProperties2NV>(), offset_of!(QueueFamilyCheckpointProperties2NV, s_type), offset_of!(QueueFamilyCheckpointProperties2NV, p_next), offset_of!(QueueFamilyCheckpointProperties2NV, checkpoint_execution_stage_mask));
    println!("CheckpointData2NV {} {} {} {} {} {}", size_of::<CheckpointData2NV>(), align_of::<CheckpointData2NV>(), offset_of!(CheckpointData2NV, s_type), offset_of!(CheckpointData2NV, p_next), offset_of!(CheckpointData2NV, stage), offset_of!(CheckpointData2NV, p_checkpoint_marker));
    println!("PhysicalDeviceSynchronization2Features {} {} {} {} {}", size_of::<PhysicalDeviceSynchronization2Features>(), align_of::<PhysicalDeviceSynchronization2Features>(), offset_of!(PhysicalDeviceSynchronization2Features, s_type), offset_of!(PhysicalDeviceSynchronization2Features, p_next), offset_of!(PhysicalDeviceSynchronization2Features, synchronization2));
    println!("PhysicalDeviceUnifiedImageLayoutsFeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceUnifiedImageLayoutsFeaturesKHR>(), align_of::<PhysicalDeviceUnifiedImageLayoutsFeaturesKHR>(), offset_of!(PhysicalDeviceUnifiedImageLayoutsFeaturesKHR, s_type), offset_of!(PhysicalDeviceUnifiedImageLayoutsFeaturesKHR, p_next), offset_of!(PhysicalDeviceUnifiedImageLayoutsFeaturesKHR, unified_image_layouts), offset_of!(PhysicalDeviceUnifiedImageLayoutsFeaturesKHR, unified_image_layouts_video));
    println!("PhysicalDeviceHostImageCopyFeatures {} {} {} {} {}", size_of::<PhysicalDeviceHostImageCopyFeatures>(), align_of::<PhysicalDeviceHostImageCopyFeatures>(), offset_of!(PhysicalDeviceHostImageCopyFeatures, s_type), offset_of!(PhysicalDeviceHostImageCopyFeatures, p_next), offset_of!(PhysicalDeviceHostImageCopyFeatures, host_image_copy));
    println!("PhysicalDeviceHostImageCopyProperties {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceHostImageCopyProperties>(), align_of::<PhysicalDeviceHostImageCopyProperties>(), offset_of!(PhysicalDeviceHostImageCopyProperties, s_type), offset_of!(PhysicalDeviceHostImageCopyProperties, p_next), offset_of!(PhysicalDeviceHostImageCopyProperties, copy_src_layout_count), offset_of!(PhysicalDeviceHostImageCopyProperties, p_copy_src_layouts), offset_of!(PhysicalDeviceHostImageCopyProperties, copy_dst_layout_count), offset_of!(PhysicalDeviceHostImageCopyProperties, p_copy_dst_layouts), offset_of!(PhysicalDeviceHostImageCopyProperties, optimal_tiling_layout_uuid), offset_of!(PhysicalDeviceHostImageCopyProperties, identical_memory_type_requirements));
    println!("MemoryToImageCopy {} {} {} {} {} {} {} {} {} {}", size_of::<MemoryToImageCopy>(), align_of::<MemoryToImageCopy>(), offset_of!(MemoryToImageCopy, s_type), offset_of!(MemoryToImageCopy, p_next), offset_of!(MemoryToImageCopy, p_host_pointer), offset_of!(MemoryToImageCopy, memory_row_length), offset_of!(MemoryToImageCopy, memory_image_height), offset_of!(MemoryToImageCopy, image_subresource), offset_of!(MemoryToImageCopy, image_offset), offset_of!(MemoryToImageCopy, image_extent));
    println!("ImageToMemoryCopy {} {} {} {} {} {} {} {} {} {}", size_of::<ImageToMemoryCopy>(), align_of::<ImageToMemoryCopy>(), offset_of!(ImageToMemoryCopy, s_type), offset_of!(ImageToMemoryCopy, p_next), offset_of!(ImageToMemoryCopy, p_host_pointer), offset_of!(ImageToMemoryCopy, memory_row_length), offset_of!(ImageToMemoryCopy, memory_image_height), offset_of!(ImageToMemoryCopy, image_subresource), offset_of!(ImageToMemoryCopy, image_offset), offset_of!(ImageToMemoryCopy, image_extent));
    println!("CopyMemoryToImageInfo {} {} {} {} {} {} {} {} {}", size_of::<CopyMemoryToImageInfo>(), align_of::<CopyMemoryToImageInfo>(), offset_of!(CopyMemoryToImageInfo, s_type), offset_of!(CopyMemoryToImageInfo, p_next), offset_of!(CopyMemoryToImageInfo, flags), offset_of!(CopyMemoryToImageInfo, dst_image), offset_of!(CopyMemoryToImageInfo, dst_image_layout), offset_of!(CopyMemoryToImageInfo, region_count), offset_of!(CopyMemoryToImageInfo, p_regions));
    println!("CopyImageToMemoryInfo {} {} {} {} {} {} {} {} {}", size_of::<CopyImageToMemoryInfo>(), align_of::<CopyImageToMemoryInfo>(), offset_of!(CopyImageToMemoryInfo, s_type), offset_of!(CopyImageToMemoryInfo, p_next), offset_of!(CopyImageToMemoryInfo, flags), offset_of!(CopyImageToMemoryInfo, src_image), offset_of!(CopyImageToMemoryInfo, src_image_layout), offset_of!(CopyImageToMemoryInfo, region_count), offset_of!(CopyImageToMemoryInfo, p_regions));
    println!("CopyImageToImageInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<CopyImageToImageInfo>(), align_of::<CopyImageToImageInfo>(), offset_of!(CopyImageToImageInfo, s_type), offset_of!(CopyImageToImageInfo, p_next), offset_of!(CopyImageToImageInfo, flags), offset_of!(CopyImageToImageInfo, src_image), offset_of!(CopyImageToImageInfo, src_image_layout), offset_of!(CopyImageToImageInfo, dst_image), offset_of!(CopyImageToImageInfo, dst_image_layout), offset_of!(CopyImageToImageInfo, region_count), offset_of!(CopyImageToImageInfo, p_regions));
    println!("HostImageLayoutTransitionInfo {} {} {} {} {} {} {} {}", size_of::<HostImageLayoutTransitionInfo>(), align_of::<HostImageLayoutTransitionInfo>(), offset_of!(HostImageLayoutTransitionInfo, s_type), offset_of!(HostImageLayoutTransitionInfo, p_next), offset_of!(HostImageLayoutTransitionInfo, image), offset_of!(HostImageLayoutTransitionInfo, old_layout), offset_of!(HostImageLayoutTransitionInfo, new_layout), offset_of!(HostImageLayoutTransitionInfo, subresource_range));
    println!("SubresourceHostMemcpySize {} {} {} {} {}", size_of::<SubresourceHostMemcpySize>(), align_of::<SubresourceHostMemcpySize>(), offset_of!(SubresourceHostMemcpySize, s_type), offset_of!(SubresourceHostMemcpySize, p_next), offset_of!(SubresourceHostMemcpySize, size));
    println!("HostImageCopyDevicePerformanceQuery {} {} {} {} {} {}", size_of::<HostImageCopyDevicePerformanceQuery>(), align_of::<HostImageCopyDevicePerformanceQuery>(), offset_of!(HostImageCopyDevicePerformanceQuery, s_type), offset_of!(HostImageCopyDevicePerformanceQuery, p_next), offset_of!(HostImageCopyDevicePerformanceQuery, optimal_device_access), offset_of!(HostImageCopyDevicePerformanceQuery, identical_memory_layout));
    println!("PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(), align_of::<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(), offset_of!(PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, s_type), offset_of!(PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, p_next), offset_of!(PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, primitives_generated_query), offset_of!(PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, primitives_generated_query_with_rasterizer_discard), offset_of!(PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, primitives_generated_query_with_non_zero_streams));
    println!("PhysicalDeviceLegacyDitheringFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceLegacyDitheringFeaturesEXT>(), align_of::<PhysicalDeviceLegacyDitheringFeaturesEXT>(), offset_of!(PhysicalDeviceLegacyDitheringFeaturesEXT, s_type), offset_of!(PhysicalDeviceLegacyDitheringFeaturesEXT, p_next), offset_of!(PhysicalDeviceLegacyDitheringFeaturesEXT, legacy_dithering));
    println!("PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>(), align_of::<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>(), offset_of!(PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, s_type), offset_of!(PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, p_next), offset_of!(PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, multisampled_render_to_single_sampled));
    println!("SurfaceCapabilitiesPresentId2KHR {} {} {} {} {}", size_of::<SurfaceCapabilitiesPresentId2KHR>(), align_of::<SurfaceCapabilitiesPresentId2KHR>(), offset_of!(SurfaceCapabilitiesPresentId2KHR, s_type), offset_of!(SurfaceCapabilitiesPresentId2KHR, p_next), offset_of!(SurfaceCapabilitiesPresentId2KHR, present_id2_supported));
    println!("SurfaceCapabilitiesPresentWait2KHR {} {} {} {} {}", size_of::<SurfaceCapabilitiesPresentWait2KHR>(), align_of::<SurfaceCapabilitiesPresentWait2KHR>(), offset_of!(SurfaceCapabilitiesPresentWait2KHR, s_type), offset_of!(SurfaceCapabilitiesPresentWait2KHR, p_next), offset_of!(SurfaceCapabilitiesPresentWait2KHR, present_wait2_supported));
    println!("SubpassResolvePerformanceQueryEXT {} {} {} {} {}", size_of::<SubpassResolvePerformanceQueryEXT>(), align_of::<SubpassResolvePerformanceQueryEXT>(), offset_of!(SubpassResolvePerformanceQueryEXT, s_type), offset_of!(SubpassResolvePerformanceQueryEXT, p_next), offset_of!(SubpassResolvePerformanceQueryEXT, optimal));
    println!("MultisampledRenderToSingleSampledInfoEXT {} {} {} {} {} {}", size_of::<MultisampledRenderToSingleSampledInfoEXT>(), align_of::<MultisampledRenderToSingleSampledInfoEXT>(), offset_of!(MultisampledRenderToSingleSampledInfoEXT, s_type), offset_of!(MultisampledRenderToSingleSampledInfoEXT, p_next), offset_of!(MultisampledRenderToSingleSampledInfoEXT, multisampled_render_to_single_sampled_enable), offset_of!(MultisampledRenderToSingleSampledInfoEXT, rasterization_samples));
    println!("PhysicalDevicePipelineProtectedAccessFeatures {} {} {} {} {}", size_of::<PhysicalDevicePipelineProtectedAccessFeatures>(), align_of::<PhysicalDevicePipelineProtectedAccessFeatures>(), offset_of!(PhysicalDevicePipelineProtectedAccessFeatures, s_type), offset_of!(PhysicalDevicePipelineProtectedAccessFeatures, p_next), offset_of!(PhysicalDevicePipelineProtectedAccessFeatures, pipeline_protected_access));
    println!("QueueFamilyVideoPropertiesKHR {} {} {} {} {}", size_of::<QueueFamilyVideoPropertiesKHR>(), align_of::<QueueFamilyVideoPropertiesKHR>(), offset_of!(QueueFamilyVideoPropertiesKHR, s_type), offset_of!(QueueFamilyVideoPropertiesKHR, p_next), offset_of!(QueueFamilyVideoPropertiesKHR, video_codec_operations));
    println!("QueueFamilyQueryResultStatusPropertiesKHR {} {} {} {} {}", size_of::<QueueFamilyQueryResultStatusPropertiesKHR>(), align_of::<QueueFamilyQueryResultStatusPropertiesKHR>(), offset_of!(QueueFamilyQueryResultStatusPropertiesKHR, s_type), offset_of!(QueueFamilyQueryResultStatusPropertiesKHR, p_next), offset_of!(QueueFamilyQueryResultStatusPropertiesKHR, query_result_status_support));
    println!("VideoProfileListInfoKHR {} {} {} {} {} {}", size_of::<VideoProfileListInfoKHR>(), align_of::<VideoProfileListInfoKHR>(), offset_of!(VideoProfileListInfoKHR, s_type), offset_of!(VideoProfileListInfoKHR, p_next), offset_of!(VideoProfileListInfoKHR, profile_count), offset_of!(VideoProfileListInfoKHR, p_profiles));
    println!("PhysicalDeviceVideoFormatInfoKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoFormatInfoKHR>(), align_of::<PhysicalDeviceVideoFormatInfoKHR>(), offset_of!(PhysicalDeviceVideoFormatInfoKHR, s_type), offset_of!(PhysicalDeviceVideoFormatInfoKHR, p_next), offset_of!(PhysicalDeviceVideoFormatInfoKHR, image_usage));
    println!("VideoFormatPropertiesKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoFormatPropertiesKHR>(), align_of::<VideoFormatPropertiesKHR>(), offset_of!(VideoFormatPropertiesKHR, s_type), offset_of!(VideoFormatPropertiesKHR, p_next), offset_of!(VideoFormatPropertiesKHR, format), offset_of!(VideoFormatPropertiesKHR, component_mapping), offset_of!(VideoFormatPropertiesKHR, image_create_flags), offset_of!(VideoFormatPropertiesKHR, image_type), offset_of!(VideoFormatPropertiesKHR, image_tiling), offset_of!(VideoFormatPropertiesKHR, image_usage_flags));
    println!("VideoEncodeQuantizationMapCapabilitiesKHR {} {} {} {} {}", size_of::<VideoEncodeQuantizationMapCapabilitiesKHR>(), align_of::<VideoEncodeQuantizationMapCapabilitiesKHR>(), offset_of!(VideoEncodeQuantizationMapCapabilitiesKHR, s_type), offset_of!(VideoEncodeQuantizationMapCapabilitiesKHR, p_next), offset_of!(VideoEncodeQuantizationMapCapabilitiesKHR, max_quantization_map_extent));
    println!("VideoEncodeH264QuantizationMapCapabilitiesKHR {} {} {} {} {} {}", size_of::<VideoEncodeH264QuantizationMapCapabilitiesKHR>(), align_of::<VideoEncodeH264QuantizationMapCapabilitiesKHR>(), offset_of!(VideoEncodeH264QuantizationMapCapabilitiesKHR, s_type), offset_of!(VideoEncodeH264QuantizationMapCapabilitiesKHR, p_next), offset_of!(VideoEncodeH264QuantizationMapCapabilitiesKHR, min_qp_delta), offset_of!(VideoEncodeH264QuantizationMapCapabilitiesKHR, max_qp_delta));
    println!("VideoEncodeH265QuantizationMapCapabilitiesKHR {} {} {} {} {} {}", size_of::<VideoEncodeH265QuantizationMapCapabilitiesKHR>(), align_of::<VideoEncodeH265QuantizationMapCapabilitiesKHR>(), offset_of!(VideoEncodeH265QuantizationMapCapabilitiesKHR, s_type), offset_of!(VideoEncodeH265QuantizationMapCapabilitiesKHR, p_next), offset_of!(VideoEncodeH265QuantizationMapCapabilitiesKHR, min_qp_delta), offset_of!(VideoEncodeH265QuantizationMapCapabilitiesKHR, max_qp_delta));
    println!("VideoEncodeAV1QuantizationMapCapabilitiesKHR {} {} {} {} {} {}", size_of::<VideoEncodeAV1QuantizationMapCapabilitiesKHR>(), align_of::<VideoEncodeAV1QuantizationMapCapabilitiesKHR>(), offset_of!(VideoEncodeAV1QuantizationMapCapabilitiesKHR, s_type), offset_of!(VideoEncodeAV1QuantizationMapCapabilitiesKHR, p_next), offset_of!(VideoEncodeAV1QuantizationMapCapabilitiesKHR, min_q_index_delta), offset_of!(VideoEncodeAV1QuantizationMapCapabilitiesKHR, max_q_index_delta));
    println!("VideoFormatQuantizationMapPropertiesKHR {} {} {} {} {}", size_of::<VideoFormatQuantizationMapPropertiesKHR>(), align_of::<VideoFormatQuantizationMapPropertiesKHR>(), offset_of!(VideoFormatQuantizationMapPropertiesKHR, s_type), offset_of!(VideoFormatQuantizationMapPropertiesKHR, p_next), offset_of!(VideoFormatQuantizationMapPropertiesKHR, quantization_map_texel_size));
    println!("VideoFormatH265QuantizationMapPropertiesKHR {} {} {} {} {}", size_of::<VideoFormatH265QuantizationMapPropertiesKHR>(), align_of::<VideoFormatH265QuantizationMapPropertiesKHR>(), offset_of!(VideoFormatH265QuantizationMapPropertiesKHR, s_type), offset_of!(VideoFormatH265QuantizationMapPropertiesKHR, p_next), offset_of!(VideoFormatH265QuantizationMapPropertiesKHR, compatible_ctb_sizes));
    println!("VideoFormatAV1QuantizationMapPropertiesKHR {} {} {} {} {}", size_of::<VideoFormatAV1QuantizationMapPropertiesKHR>(), align_of::<VideoFormatAV1QuantizationMapPropertiesKHR>(), offset_of!(VideoFormatAV1QuantizationMapPropertiesKHR, s_type), offset_of!(VideoFormatAV1QuantizationMapPropertiesKHR, p_next), offset_of!(VideoFormatAV1QuantizationMapPropertiesKHR, compatible_superblock_sizes));
    println!("VideoProfileInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoProfileInfoKHR>(), align_of::<VideoProfileInfoKHR>(), offset_of!(VideoProfileInfoKHR, s_type), offset_of!(VideoProfileInfoKHR, p_next), offset_of!(VideoProfileInfoKHR, video_codec_operation), offset_of!(VideoProfileInfoKHR, chroma_subsampling), offset_of!(VideoProfileInfoKHR, luma_bit_depth), offset_of!(VideoProfileInfoKHR, chroma_bit_depth));
    println!("VideoCapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoCapabilitiesKHR>(), align_of::<VideoCapabilitiesKHR>(), offset_of!(VideoCapabilitiesKHR, s_type), offset_of!(VideoCapabilitiesKHR, p_next), offset_of!(VideoCapabilitiesKHR, flags), offset_of!(VideoCapabilitiesKHR, min_bitstream_buffer_offset_alignment), offset_of!(VideoCapabilitiesKHR, min_bitstream_buffer_size_alignment), offset_of!(VideoCapabilitiesKHR, picture_access_granularity), offset_of!(VideoCapabilitiesKHR, min_coded_extent), offset_of!(VideoCapabilitiesKHR, max_coded_extent), offset_of!(VideoCapabilitiesKHR, max_dpb_slots), offset_of!(VideoCapabilitiesKHR, max_active_reference_pictures), offset_of!(VideoCapabilitiesKHR, std_header_version));
    println!("VideoSessionMemoryRequirementsKHR {} {} {} {} {} {}", size_of::<VideoSessionMemoryRequirementsKHR>(), align_of::<VideoSessionMemoryRequirementsKHR>(), offset_of!(VideoSessionMemoryRequirementsKHR, s_type), offset_of!(VideoSessionMemoryRequirementsKHR, p_next), offset_of!(VideoSessionMemoryRequirementsKHR, memory_bind_index), offset_of!(VideoSessionMemoryRequirementsKHR, memory_requirements));
    println!("BindVideoSessionMemoryInfoKHR {} {} {} {} {} {} {} {}", size_of::<BindVideoSessionMemoryInfoKHR>(), align_of::<BindVideoSessionMemoryInfoKHR>(), offset_of!(BindVideoSessionMemoryInfoKHR, s_type), offset_of!(BindVideoSessionMemoryInfoKHR, p_next), offset_of!(BindVideoSessionMemoryInfoKHR, memory_bind_index), offset_of!(BindVideoSessionMemoryInfoKHR, memory), offset_of!(BindVideoSessionMemoryInfoKHR, memory_offset), offset_of!(BindVideoSessionMemoryInfoKHR, memory_size));
    println!("VideoPictureResourceInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoPictureResourceInfoKHR>(), align_of::<VideoPictureResourceInfoKHR>(), offset_of!(VideoPictureResourceInfoKHR, s_type), offset_of!(VideoPictureResourceInfoKHR, p_next), offset_of!(VideoPictureResourceInfoKHR, coded_offset), offset_of!(VideoPictureResourceInfoKHR, coded_extent), offset_of!(VideoPictureResourceInfoKHR, base_array_layer), offset_of!(VideoPictureResourceInfoKHR, image_view_binding));
    println!("VideoReferenceSlotInfoKHR {} {} {} {} {} {}", size_of::<VideoReferenceSlotInfoKHR>(), align_of::<VideoReferenceSlotInfoKHR>(), offset_of!(VideoReferenceSlotInfoKHR, s_type), offset_of!(VideoReferenceSlotInfoKHR, p_next), offset_of!(VideoReferenceSlotInfoKHR, slot_index), offset_of!(VideoReferenceSlotInfoKHR, p_picture_resource));
    println!("VideoDecodeCapabilitiesKHR {} {} {} {} {}", size_of::<VideoDecodeCapabilitiesKHR>(), align_of::<VideoDecodeCapabilitiesKHR>(), offset_of!(VideoDecodeCapabilitiesKHR, s_type), offset_of!(VideoDecodeCapabilitiesKHR, p_next), offset_of!(VideoDecodeCapabilitiesKHR, flags));
    println!("VideoDecodeUsageInfoKHR {} {} {} {} {}", size_of::<VideoDecodeUsageInfoKHR>(), align_of::<VideoDecodeUsageInfoKHR>(), offset_of!(VideoDecodeUsageInfoKHR, s_type), offset_of!(VideoDecodeUsageInfoKHR, p_next), offset_of!(VideoDecodeUsageInfoKHR, video_usage_hints));
    println!("VideoDecodeInfoKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoDecodeInfoKHR>(), align_of::<VideoDecodeInfoKHR>(), offset_of!(VideoDecodeInfoKHR, s_type), offset_of!(VideoDecodeInfoKHR, p_next), offset_of!(VideoDecodeInfoKHR, flags), offset_of!(VideoDecodeInfoKHR, src_buffer), offset_of!(VideoDecodeInfoKHR, src_buffer_offset), offset_of!(VideoDecodeInfoKHR, src_buffer_range), offset_of!(VideoDecodeInfoKHR, dst_picture_resource), offset_of!(VideoDecodeInfoKHR, p_setup_reference_slot), offset_of!(VideoDecodeInfoKHR, reference_slot_count), offset_of!(VideoDecodeInfoKHR, p_reference_slots));
    println!("PhysicalDeviceVideoMaintenance1FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoMaintenance1FeaturesKHR>(), align_of::<PhysicalDeviceVideoMaintenance1FeaturesKHR>(), offset_of!(PhysicalDeviceVideoMaintenance1FeaturesKHR, s_type), offset_of!(PhysicalDeviceVideoMaintenance1FeaturesKHR, p_next), offset_of!(PhysicalDeviceVideoMaintenance1FeaturesKHR, video_maintenance1));
    println!("PhysicalDeviceVideoMaintenance2FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoMaintenance2FeaturesKHR>(), align_of::<PhysicalDeviceVideoMaintenance2FeaturesKHR>(), offset_of!(PhysicalDeviceVideoMaintenance2FeaturesKHR, s_type), offset_of!(PhysicalDeviceVideoMaintenance2FeaturesKHR, p_next), offset_of!(PhysicalDeviceVideoMaintenance2FeaturesKHR, video_maintenance2));
    println!("VideoInlineQueryInfoKHR {} {} {} {} {} {} {}", size_of::<VideoInlineQueryInfoKHR>(), align_of::<VideoInlineQueryInfoKHR>(), offset_of!(VideoInlineQueryInfoKHR, s_type), offset_of!(VideoInlineQueryInfoKHR, p_next), offset_of!(VideoInlineQueryInfoKHR, query_pool), offset_of!(VideoInlineQueryInfoKHR, first_query), offset_of!(VideoInlineQueryInfoKHR, query_count));
    println!("VideoDecodeH264ProfileInfoKHR {} {} {} {} {} {}", size_of::<VideoDecodeH264ProfileInfoKHR>(), align_of::<VideoDecodeH264ProfileInfoKHR>(), offset_of!(VideoDecodeH264ProfileInfoKHR, s_type), offset_of!(VideoDecodeH264ProfileInfoKHR, p_next), offset_of!(VideoDecodeH264ProfileInfoKHR, std_profile_idc), offset_of!(VideoDecodeH264ProfileInfoKHR, picture_layout));
    println!("VideoDecodeH264CapabilitiesKHR {} {} {} {} {} {}", size_of::<VideoDecodeH264CapabilitiesKHR>(), align_of::<VideoDecodeH264CapabilitiesKHR>(), offset_of!(VideoDecodeH264CapabilitiesKHR, s_type), offset_of!(VideoDecodeH264CapabilitiesKHR, p_next), offset_of!(VideoDecodeH264CapabilitiesKHR, max_level_idc), offset_of!(VideoDecodeH264CapabilitiesKHR, field_offset_granularity));
    println!("VideoDecodeH264SessionParametersAddInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoDecodeH264SessionParametersAddInfoKHR>(), align_of::<VideoDecodeH264SessionParametersAddInfoKHR>(), offset_of!(VideoDecodeH264SessionParametersAddInfoKHR, s_type), offset_of!(VideoDecodeH264SessionParametersAddInfoKHR, p_next), offset_of!(VideoDecodeH264SessionParametersAddInfoKHR, std_sps_count), offset_of!(VideoDecodeH264SessionParametersAddInfoKHR, p_std_sp_ss), offset_of!(VideoDecodeH264SessionParametersAddInfoKHR, std_pps_count), offset_of!(VideoDecodeH264SessionParametersAddInfoKHR, p_std_pp_ss));
    println!("VideoDecodeH264SessionParametersCreateInfoKHR {} {} {} {} {} {} {}", size_of::<VideoDecodeH264SessionParametersCreateInfoKHR>(), align_of::<VideoDecodeH264SessionParametersCreateInfoKHR>(), offset_of!(VideoDecodeH264SessionParametersCreateInfoKHR, s_type), offset_of!(VideoDecodeH264SessionParametersCreateInfoKHR, p_next), offset_of!(VideoDecodeH264SessionParametersCreateInfoKHR, max_std_sps_count), offset_of!(VideoDecodeH264SessionParametersCreateInfoKHR, max_std_pps_count), offset_of!(VideoDecodeH264SessionParametersCreateInfoKHR, p_parameters_add_info));
    println!("VideoDecodeH264InlineSessionParametersInfoKHR {} {} {} {} {} {}", size_of::<VideoDecodeH264InlineSessionParametersInfoKHR>(), align_of::<VideoDecodeH264InlineSessionParametersInfoKHR>(), offset_of!(VideoDecodeH264InlineSessionParametersInfoKHR, s_type), offset_of!(VideoDecodeH264InlineSessionParametersInfoKHR, p_next), offset_of!(VideoDecodeH264InlineSessionParametersInfoKHR, p_std_sps), offset_of!(VideoDecodeH264InlineSessionParametersInfoKHR, p_std_pps));
    println!("VideoDecodeH264PictureInfoKHR {} {} {} {} {} {} {}", size_of::<VideoDecodeH264PictureInfoKHR>(), align_of::<VideoDecodeH264PictureInfoKHR>(), offset_of!(VideoDecodeH264PictureInfoKHR, s_type), offset_of!(VideoDecodeH264PictureInfoKHR, p_next), offset_of!(VideoDecodeH264PictureInfoKHR, p_std_picture_info), offset_of!(VideoDecodeH264PictureInfoKHR, slice_count), offset_of!(VideoDecodeH264PictureInfoKHR, p_slice_offsets));
    println!("VideoDecodeH264DpbSlotInfoKHR {} {} {} {} {}", size_of::<VideoDecodeH264DpbSlotInfoKHR>(), align_of::<VideoDecodeH264DpbSlotInfoKHR>(), offset_of!(VideoDecodeH264DpbSlotInfoKHR, s_type), offset_of!(VideoDecodeH264DpbSlotInfoKHR, p_next), offset_of!(VideoDecodeH264DpbSlotInfoKHR, p_std_reference_info));
    println!("VideoDecodeH265ProfileInfoKHR {} {} {} {} {}", size_of::<VideoDecodeH265ProfileInfoKHR>(), align_of::<VideoDecodeH265ProfileInfoKHR>(), offset_of!(VideoDecodeH265ProfileInfoKHR, s_type), offset_of!(VideoDecodeH265ProfileInfoKHR, p_next), offset_of!(VideoDecodeH265ProfileInfoKHR, std_profile_idc));
    println!("VideoDecodeH265CapabilitiesKHR {} {} {} {} {}", size_of::<VideoDecodeH265CapabilitiesKHR>(), align_of::<VideoDecodeH265CapabilitiesKHR>(), offset_of!(VideoDecodeH265CapabilitiesKHR, s_type), offset_of!(VideoDecodeH265CapabilitiesKHR, p_next), offset_of!(VideoDecodeH265CapabilitiesKHR, max_level_idc));
    println!("VideoDecodeH265SessionParametersAddInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoDecodeH265SessionParametersAddInfoKHR>(), align_of::<VideoDecodeH265SessionParametersAddInfoKHR>(), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, s_type), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, p_next), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, std_vps_count), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, p_std_vp_ss), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, std_sps_count), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, p_std_sp_ss), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, std_pps_count), offset_of!(VideoDecodeH265SessionParametersAddInfoKHR, p_std_pp_ss));
    println!("VideoDecodeH265SessionParametersCreateInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoDecodeH265SessionParametersCreateInfoKHR>(), align_of::<VideoDecodeH265SessionParametersCreateInfoKHR>(), offset_of!(VideoDecodeH265SessionParametersCreateInfoKHR, s_type), offset_of!(VideoDecodeH265SessionParametersCreateInfoKHR, p_next), offset_of!(VideoDecodeH265SessionParametersCreateInfoKHR, max_std_vps_count), offset_of!(VideoDecodeH265SessionParametersCreateInfoKHR, max_std_sps_count), offset_of!(VideoDecodeH265SessionParametersCreateInfoKHR, max_std_pps_count), offset_of!(VideoDecodeH265SessionParametersCreateInfoKHR, p_parameters_add_info));
    println!("VideoDecodeH265InlineSessionParametersInfoKHR {} {} {} {} {} {} {}", size_of::<VideoDecodeH265InlineSessionParametersInfoKHR>(), align_of::<VideoDecodeH265InlineSessionParametersInfoKHR>(), offset_of!(VideoDecodeH265InlineSessionParametersInfoKHR, s_type), offset_of!(VideoDecodeH265InlineSessionParametersInfoKHR, p_next), offset_of!(VideoDecodeH265InlineSessionParametersInfoKHR, p_std_vps), offset_of!(VideoDecodeH265InlineSessionParametersInfoKHR, p_std_sps), offset_of!(VideoDecodeH265InlineSessionParametersInfoKHR, p_std_pps));
    println!("VideoDecodeH265PictureInfoKHR {} {} {} {} {} {} {}", size_of::<VideoDecodeH265PictureInfoKHR>(), align_of::<VideoDecodeH265PictureInfoKHR>(), offset_of!(VideoDecodeH265PictureInfoKHR, s_type), offset_of!(VideoDecodeH265PictureInfoKHR, p_next), offset_of!(VideoDecodeH265PictureInfoKHR, p_std_picture_info), offset_of!(VideoDecodeH265PictureInfoKHR, slice_segment_count), offset_of!(VideoDecodeH265PictureInfoKHR, p_slice_segment_offsets));
    println!("VideoDecodeH265DpbSlotInfoKHR {} {} {} {} {}", size_of::<VideoDecodeH265DpbSlotInfoKHR>(), align_of::<VideoDecodeH265DpbSlotInfoKHR>(), offset_of!(VideoDecodeH265DpbSlotInfoKHR, s_type), offset_of!(VideoDecodeH265DpbSlotInfoKHR, p_next), offset_of!(VideoDecodeH265DpbSlotInfoKHR, p_std_reference_info));
    println!("PhysicalDeviceVideoDecodeVP9FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoDecodeVP9FeaturesKHR>(), align_of::<PhysicalDeviceVideoDecodeVP9FeaturesKHR>(), offset_of!(PhysicalDeviceVideoDecodeVP9FeaturesKHR, s_type), offset_of!(PhysicalDeviceVideoDecodeVP9FeaturesKHR, p_next), offset_of!(PhysicalDeviceVideoDecodeVP9FeaturesKHR, video_decode_vp9));
    println!("VideoDecodeVP9ProfileInfoKHR {} {} {} {} {}", size_of::<VideoDecodeVP9ProfileInfoKHR>(), align_of::<VideoDecodeVP9ProfileInfoKHR>(), offset_of!(VideoDecodeVP9ProfileInfoKHR, s_type), offset_of!(VideoDecodeVP9ProfileInfoKHR, p_next), offset_of!(VideoDecodeVP9ProfileInfoKHR, std_profile));
    println!("VideoDecodeVP9CapabilitiesKHR {} {} {} {} {}", size_of::<VideoDecodeVP9CapabilitiesKHR>(), align_of::<VideoDecodeVP9CapabilitiesKHR>(), offset_of!(VideoDecodeVP9CapabilitiesKHR, s_type), offset_of!(VideoDecodeVP9CapabilitiesKHR, p_next), offset_of!(VideoDecodeVP9CapabilitiesKHR, max_level));
    println!("VideoDecodeVP9PictureInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<VideoDecodeVP9PictureInfoKHR>(), align_of::<VideoDecodeVP9PictureInfoKHR>(), offset_of!(VideoDecodeVP9PictureInfoKHR, s_type), offset_of!(VideoDecodeVP9PictureInfoKHR, p_next), offset_of!(VideoDecodeVP9PictureInfoKHR, p_std_picture_info), offset_of!(VideoDecodeVP9PictureInfoKHR, reference_name_slot_indices), offset_of!(VideoDecodeVP9PictureInfoKHR, uncompressed_header_offset), offset_of!(VideoDecodeVP9PictureInfoKHR, compressed_header_offset), offset_of!(VideoDecodeVP9PictureInfoKHR, tiles_offset));
    println!("VideoDecodeAV1ProfileInfoKHR {} {} {} {} {} {}", size_of::<VideoDecodeAV1ProfileInfoKHR>(), align_of::<VideoDecodeAV1ProfileInfoKHR>(), offset_of!(VideoDecodeAV1ProfileInfoKHR, s_type), offset_of!(VideoDecodeAV1ProfileInfoKHR, p_next), offset_of!(VideoDecodeAV1ProfileInfoKHR, std_profile), offset_of!(VideoDecodeAV1ProfileInfoKHR, film_grain_support));
    println!("VideoDecodeAV1CapabilitiesKHR {} {} {} {} {}", size_of::<VideoDecodeAV1CapabilitiesKHR>(), align_of::<VideoDecodeAV1CapabilitiesKHR>(), offset_of!(VideoDecodeAV1CapabilitiesKHR, s_type), offset_of!(VideoDecodeAV1CapabilitiesKHR, p_next), offset_of!(VideoDecodeAV1CapabilitiesKHR, max_level));
    println!("VideoDecodeAV1SessionParametersCreateInfoKHR {} {} {} {} {}", size_of::<VideoDecodeAV1SessionParametersCreateInfoKHR>(), align_of::<VideoDecodeAV1SessionParametersCreateInfoKHR>(), offset_of!(VideoDecodeAV1SessionParametersCreateInfoKHR, s_type), offset_of!(VideoDecodeAV1SessionParametersCreateInfoKHR, p_next), offset_of!(VideoDecodeAV1SessionParametersCreateInfoKHR, p_std_sequence_header));
    println!("VideoDecodeAV1InlineSessionParametersInfoKHR {} {} {} {} {}", size_of::<VideoDecodeAV1InlineSessionParametersInfoKHR>(), align_of::<VideoDecodeAV1InlineSessionParametersInfoKHR>(), offset_of!(VideoDecodeAV1InlineSessionParametersInfoKHR, s_type), offset_of!(VideoDecodeAV1InlineSessionParametersInfoKHR, p_next), offset_of!(VideoDecodeAV1InlineSessionParametersInfoKHR, p_std_sequence_header));
    println!("VideoDecodeAV1PictureInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoDecodeAV1PictureInfoKHR>(), align_of::<VideoDecodeAV1PictureInfoKHR>(), offset_of!(VideoDecodeAV1PictureInfoKHR, s_type), offset_of!(VideoDecodeAV1PictureInfoKHR, p_next), offset_of!(VideoDecodeAV1PictureInfoKHR, p_std_picture_info), offset_of!(VideoDecodeAV1PictureInfoKHR, reference_name_slot_indices), offset_of!(VideoDecodeAV1PictureInfoKHR, frame_header_offset), offset_of!(VideoDecodeAV1PictureInfoKHR, tile_count), offset_of!(VideoDecodeAV1PictureInfoKHR, p_tile_offsets), offset_of!(VideoDecodeAV1PictureInfoKHR, p_tile_sizes));
    println!("VideoDecodeAV1DpbSlotInfoKHR {} {} {} {} {}", size_of::<VideoDecodeAV1DpbSlotInfoKHR>(), align_of::<VideoDecodeAV1DpbSlotInfoKHR>(), offset_of!(VideoDecodeAV1DpbSlotInfoKHR, s_type), offset_of!(VideoDecodeAV1DpbSlotInfoKHR, p_next), offset_of!(VideoDecodeAV1DpbSlotInfoKHR, p_std_reference_info));
    println!("VideoSessionCreateInfoKHR {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoSessionCreateInfoKHR>(), align_of::<VideoSessionCreateInfoKHR>(), offset_of!(VideoSessionCreateInfoKHR, s_type), offset_of!(VideoSessionCreateInfoKHR, p_next), offset_of!(VideoSessionCreateInfoKHR, queue_family_index), offset_of!(VideoSessionCreateInfoKHR, flags), offset_of!(VideoSessionCreateInfoKHR, p_video_profile), offset_of!(VideoSessionCreateInfoKHR, picture_format), offset_of!(VideoSessionCreateInfoKHR, max_coded_extent), offset_of!(VideoSessionCreateInfoKHR, reference_picture_format), offset_of!(VideoSessionCreateInfoKHR, max_dpb_slots), offset_of!(VideoSessionCreateInfoKHR, max_active_reference_pictures), offset_of!(VideoSessionCreateInfoKHR, p_std_header_version));
    println!("VideoSessionParametersCreateInfoKHR {} {} {} {} {} {} {}", size_of::<VideoSessionParametersCreateInfoKHR>(), align_of::<VideoSessionParametersCreateInfoKHR>(), offset_of!(VideoSessionParametersCreateInfoKHR, s_type), offset_of!(VideoSessionParametersCreateInfoKHR, p_next), offset_of!(VideoSessionParametersCreateInfoKHR, flags), offset_of!(VideoSessionParametersCreateInfoKHR, video_session_parameters_template), offset_of!(VideoSessionParametersCreateInfoKHR, video_session));
    println!("VideoSessionParametersUpdateInfoKHR {} {} {} {} {}", size_of::<VideoSessionParametersUpdateInfoKHR>(), align_of::<VideoSessionParametersUpdateInfoKHR>(), offset_of!(VideoSessionParametersUpdateInfoKHR, s_type), offset_of!(VideoSessionParametersUpdateInfoKHR, p_next), offset_of!(VideoSessionParametersUpdateInfoKHR, update_sequence_count));
    println!("VideoEncodeSessionParametersGetInfoKHR {} {} {} {} {}", size_of::<VideoEncodeSessionParametersGetInfoKHR>(), align_of::<VideoEncodeSessionParametersGetInfoKHR>(), offset_of!(VideoEncodeSessionParametersGetInfoKHR, s_type), offset_of!(VideoEncodeSessionParametersGetInfoKHR, p_next), offset_of!(VideoEncodeSessionParametersGetInfoKHR, video_session_parameters));
    println!("VideoEncodeSessionParametersFeedbackInfoKHR {} {} {} {} {}", size_of::<VideoEncodeSessionParametersFeedbackInfoKHR>(), align_of::<VideoEncodeSessionParametersFeedbackInfoKHR>(), offset_of!(VideoEncodeSessionParametersFeedbackInfoKHR, s_type), offset_of!(VideoEncodeSessionParametersFeedbackInfoKHR, p_next), offset_of!(VideoEncodeSessionParametersFeedbackInfoKHR, has_overrides));
    println!("VideoBeginCodingInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<VideoBeginCodingInfoKHR>(), align_of::<VideoBeginCodingInfoKHR>(), offset_of!(VideoBeginCodingInfoKHR, s_type), offset_of!(VideoBeginCodingInfoKHR, p_next), offset_of!(VideoBeginCodingInfoKHR, flags), offset_of!(VideoBeginCodingInfoKHR, video_session), offset_of!(VideoBeginCodingInfoKHR, video_session_parameters), offset_of!(VideoBeginCodingInfoKHR, reference_slot_count), offset_of!(VideoBeginCodingInfoKHR, p_reference_slots));
    println!("VideoEndCodingInfoKHR {} {} {} {} {}", size_of::<VideoEndCodingInfoKHR>(), align_of::<VideoEndCodingInfoKHR>(), offset_of!(VideoEndCodingInfoKHR, s_type), offset_of!(VideoEndCodingInfoKHR, p_next), offset_of!(VideoEndCodingInfoKHR, flags));
    println!("VideoCodingControlInfoKHR {} {} {} {} {}", size_of::<VideoCodingControlInfoKHR>(), align_of::<VideoCodingControlInfoKHR>(), offset_of!(VideoCodingControlInfoKHR, s_type), offset_of!(VideoCodingControlInfoKHR, p_next), offset_of!(VideoCodingControlInfoKHR, flags));
    println!("VideoEncodeUsageInfoKHR {} {} {} {} {} {} {}", size_of::<VideoEncodeUsageInfoKHR>(), align_of::<VideoEncodeUsageInfoKHR>(), offset_of!(VideoEncodeUsageInfoKHR, s_type), offset_of!(VideoEncodeUsageInfoKHR, p_next), offset_of!(VideoEncodeUsageInfoKHR, video_usage_hints), offset_of!(VideoEncodeUsageInfoKHR, video_content_hints), offset_of!(VideoEncodeUsageInfoKHR, tuning_mode));
    println!("VideoEncodeInfoKHR {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeInfoKHR>(), align_of::<VideoEncodeInfoKHR>(), offset_of!(VideoEncodeInfoKHR, s_type), offset_of!(VideoEncodeInfoKHR, p_next), offset_of!(VideoEncodeInfoKHR, flags), offset_of!(VideoEncodeInfoKHR, dst_buffer), offset_of!(VideoEncodeInfoKHR, dst_buffer_offset), offset_of!(VideoEncodeInfoKHR, dst_buffer_range), offset_of!(VideoEncodeInfoKHR, src_picture_resource), offset_of!(VideoEncodeInfoKHR, p_setup_reference_slot), offset_of!(VideoEncodeInfoKHR, reference_slot_count), offset_of!(VideoEncodeInfoKHR, p_reference_slots), offset_of!(VideoEncodeInfoKHR, preceding_externally_encoded_bytes));
    println!("VideoEncodeQuantizationMapInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeQuantizationMapInfoKHR>(), align_of::<VideoEncodeQuantizationMapInfoKHR>(), offset_of!(VideoEncodeQuantizationMapInfoKHR, s_type), offset_of!(VideoEncodeQuantizationMapInfoKHR, p_next), offset_of!(VideoEncodeQuantizationMapInfoKHR, quantization_map), offset_of!(VideoEncodeQuantizationMapInfoKHR, quantization_map_extent));
    println!("VideoEncodeQuantizationMapSessionParametersCreateInfoKHR {} {} {} {} {}", size_of::<VideoEncodeQuantizationMapSessionParametersCreateInfoKHR>(), align_of::<VideoEncodeQuantizationMapSessionParametersCreateInfoKHR>(), offset_of!(VideoEncodeQuantizationMapSessionParametersCreateInfoKHR, s_type), offset_of!(VideoEncodeQuantizationMapSessionParametersCreateInfoKHR, p_next), offset_of!(VideoEncodeQuantizationMapSessionParametersCreateInfoKHR, quantization_map_texel_size));
    println!("PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>(), align_of::<PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>(), offset_of!(PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, s_type), offset_of!(PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, p_next), offset_of!(PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, video_encode_quantization_map));
    println!("QueryPoolVideoEncodeFeedbackCreateInfoKHR {} {} {} {} {}", size_of::<QueryPoolVideoEncodeFeedbackCreateInfoKHR>(), align_of::<QueryPoolVideoEncodeFeedbackCreateInfoKHR>(), offset_of!(QueryPoolVideoEncodeFeedbackCreateInfoKHR, s_type), offset_of!(QueryPoolVideoEncodeFeedbackCreateInfoKHR, p_next), offset_of!(QueryPoolVideoEncodeFeedbackCreateInfoKHR, encode_feedback_flags));
    println!("VideoEncodeQualityLevelInfoKHR {} {} {} {} {}", size_of::<VideoEncodeQualityLevelInfoKHR>(), align_of::<VideoEncodeQualityLevelInfoKHR>(), offset_of!(VideoEncodeQualityLevelInfoKHR, s_type), offset_of!(VideoEncodeQualityLevelInfoKHR, p_next), offset_of!(VideoEncodeQualityLevelInfoKHR, quality_level));
    println!("PhysicalDeviceVideoEncodeQualityLevelInfoKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceVideoEncodeQualityLevelInfoKHR>(), align_of::<PhysicalDeviceVideoEncodeQualityLevelInfoKHR>(), offset_of!(PhysicalDeviceVideoEncodeQualityLevelInfoKHR, s_type), offset_of!(PhysicalDeviceVideoEncodeQualityLevelInfoKHR, p_next), offset_of!(PhysicalDeviceVideoEncodeQualityLevelInfoKHR, p_video_profile), offset_of!(PhysicalDeviceVideoEncodeQualityLevelInfoKHR, quality_level));
    println!("VideoEncodeQualityLevelPropertiesKHR {} {} {} {} {} {}", size_of::<VideoEncodeQualityLevelPropertiesKHR>(), align_of::<VideoEncodeQualityLevelPropertiesKHR>(), offset_of!(VideoEncodeQualityLevelPropertiesKHR, s_type), offset_of!(VideoEncodeQualityLevelPropertiesKHR, p_next), offset_of!(VideoEncodeQualityLevelPropertiesKHR, preferred_rate_control_mode), offset_of!(VideoEncodeQualityLevelPropertiesKHR, preferred_rate_control_layer_count));
    println!("VideoEncodeRateControlInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeRateControlInfoKHR>(), align_of::<VideoEncodeRateControlInfoKHR>(), offset_of!(VideoEncodeRateControlInfoKHR, s_type), offset_of!(VideoEncodeRateControlInfoKHR, p_next), offset_of!(VideoEncodeRateControlInfoKHR, flags), offset_of!(VideoEncodeRateControlInfoKHR, rate_control_mode), offset_of!(VideoEncodeRateControlInfoKHR, layer_count), offset_of!(VideoEncodeRateControlInfoKHR, p_layers), offset_of!(VideoEncodeRateControlInfoKHR, virtual_buffer_size_in_ms), offset_of!(VideoEncodeRateControlInfoKHR, initial_virtual_buffer_size_in_ms));
    println!("VideoEncodeRateControlLayerInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeRateControlLayerInfoKHR>(), align_of::<VideoEncodeRateControlLayerInfoKHR>(), offset_of!(VideoEncodeRateControlLayerInfoKHR, s_type), offset_of!(VideoEncodeRateControlLayerInfoKHR, p_next), offset_of!(VideoEncodeRateControlLayerInfoKHR, average_bitrate), offset_of!(VideoEncodeRateControlLayerInfoKHR, max_bitrate), offset_of!(VideoEncodeRateControlLayerInfoKHR, frame_rate_numerator), offset_of!(VideoEncodeRateControlLayerInfoKHR, frame_rate_denominator));
    println!("VideoEncodeCapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeCapabilitiesKHR>(), align_of::<VideoEncodeCapabilitiesKHR>(), offset_of!(VideoEncodeCapabilitiesKHR, s_type), offset_of!(VideoEncodeCapabilitiesKHR, p_next), offset_of!(VideoEncodeCapabilitiesKHR, flags), offset_of!(VideoEncodeCapabilitiesKHR, rate_control_modes), offset_of!(VideoEncodeCapabilitiesKHR, max_rate_control_layers), offset_of!(VideoEncodeCapabilitiesKHR, max_bitrate), offset_of!(VideoEncodeCapabilitiesKHR, max_quality_levels), offset_of!(VideoEncodeCapabilitiesKHR, encode_input_picture_granularity), offset_of!(VideoEncodeCapabilitiesKHR, supported_encode_feedback_flags));
    println!("VideoEncodeH264CapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264CapabilitiesKHR>(), align_of::<VideoEncodeH264CapabilitiesKHR>(), offset_of!(VideoEncodeH264CapabilitiesKHR, s_type), offset_of!(VideoEncodeH264CapabilitiesKHR, p_next), offset_of!(VideoEncodeH264CapabilitiesKHR, flags), offset_of!(VideoEncodeH264CapabilitiesKHR, max_level_idc), offset_of!(VideoEncodeH264CapabilitiesKHR, max_slice_count), offset_of!(VideoEncodeH264CapabilitiesKHR, max_p_picture_l0_reference_count), offset_of!(VideoEncodeH264CapabilitiesKHR, max_b_picture_l0_reference_count), offset_of!(VideoEncodeH264CapabilitiesKHR, max_l1_reference_count), offset_of!(VideoEncodeH264CapabilitiesKHR, max_temporal_layer_count), offset_of!(VideoEncodeH264CapabilitiesKHR, expect_dyadic_temporal_layer_pattern), offset_of!(VideoEncodeH264CapabilitiesKHR, min_qp), offset_of!(VideoEncodeH264CapabilitiesKHR, max_qp), offset_of!(VideoEncodeH264CapabilitiesKHR, prefers_gop_remaining_frames), offset_of!(VideoEncodeH264CapabilitiesKHR, requires_gop_remaining_frames), offset_of!(VideoEncodeH264CapabilitiesKHR, std_syntax_flags));
    println!("VideoEncodeH264QualityLevelPropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264QualityLevelPropertiesKHR>(), align_of::<VideoEncodeH264QualityLevelPropertiesKHR>(), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, s_type), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, p_next), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_rate_control_flags), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_gop_frame_count), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_idr_period), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_consecutive_b_frame_count), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_temporal_layer_count), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_constant_qp), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_max_l0_reference_count), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_max_l1_reference_count), offset_of!(VideoEncodeH264QualityLevelPropertiesKHR, preferred_std_entropy_coding_mode_flag));
    println!("VideoEncodeH264SessionCreateInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeH264SessionCreateInfoKHR>(), align_of::<VideoEncodeH264SessionCreateInfoKHR>(), offset_of!(VideoEncodeH264SessionCreateInfoKHR, s_type), offset_of!(VideoEncodeH264SessionCreateInfoKHR, p_next), offset_of!(VideoEncodeH264SessionCreateInfoKHR, use_max_level_idc), offset_of!(VideoEncodeH264SessionCreateInfoKHR, max_level_idc));
    println!("VideoEncodeH264SessionParametersAddInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264SessionParametersAddInfoKHR>(), align_of::<VideoEncodeH264SessionParametersAddInfoKHR>(), offset_of!(VideoEncodeH264SessionParametersAddInfoKHR, s_type), offset_of!(VideoEncodeH264SessionParametersAddInfoKHR, p_next), offset_of!(VideoEncodeH264SessionParametersAddInfoKHR, std_sps_count), offset_of!(VideoEncodeH264SessionParametersAddInfoKHR, p_std_sp_ss), offset_of!(VideoEncodeH264SessionParametersAddInfoKHR, std_pps_count), offset_of!(VideoEncodeH264SessionParametersAddInfoKHR, p_std_pp_ss));
    println!("VideoEncodeH264SessionParametersCreateInfoKHR {} {} {} {} {} {} {}", size_of::<VideoEncodeH264SessionParametersCreateInfoKHR>(), align_of::<VideoEncodeH264SessionParametersCreateInfoKHR>(), offset_of!(VideoEncodeH264SessionParametersCreateInfoKHR, s_type), offset_of!(VideoEncodeH264SessionParametersCreateInfoKHR, p_next), offset_of!(VideoEncodeH264SessionParametersCreateInfoKHR, max_std_sps_count), offset_of!(VideoEncodeH264SessionParametersCreateInfoKHR, max_std_pps_count), offset_of!(VideoEncodeH264SessionParametersCreateInfoKHR, p_parameters_add_info));
    println!("VideoEncodeH264SessionParametersGetInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264SessionParametersGetInfoKHR>(), align_of::<VideoEncodeH264SessionParametersGetInfoKHR>(), offset_of!(VideoEncodeH264SessionParametersGetInfoKHR, s_type), offset_of!(VideoEncodeH264SessionParametersGetInfoKHR, p_next), offset_of!(VideoEncodeH264SessionParametersGetInfoKHR, write_std_sps), offset_of!(VideoEncodeH264SessionParametersGetInfoKHR, write_std_pps), offset_of!(VideoEncodeH264SessionParametersGetInfoKHR, std_sps_id), offset_of!(VideoEncodeH264SessionParametersGetInfoKHR, std_pps_id));
    println!("VideoEncodeH264SessionParametersFeedbackInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeH264SessionParametersFeedbackInfoKHR>(), align_of::<VideoEncodeH264SessionParametersFeedbackInfoKHR>(), offset_of!(VideoEncodeH264SessionParametersFeedbackInfoKHR, s_type), offset_of!(VideoEncodeH264SessionParametersFeedbackInfoKHR, p_next), offset_of!(VideoEncodeH264SessionParametersFeedbackInfoKHR, has_std_sps_overrides), offset_of!(VideoEncodeH264SessionParametersFeedbackInfoKHR, has_std_pps_overrides));
    println!("VideoEncodeH264DpbSlotInfoKHR {} {} {} {} {}", size_of::<VideoEncodeH264DpbSlotInfoKHR>(), align_of::<VideoEncodeH264DpbSlotInfoKHR>(), offset_of!(VideoEncodeH264DpbSlotInfoKHR, s_type), offset_of!(VideoEncodeH264DpbSlotInfoKHR, p_next), offset_of!(VideoEncodeH264DpbSlotInfoKHR, p_std_reference_info));
    println!("VideoEncodeH264PictureInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264PictureInfoKHR>(), align_of::<VideoEncodeH264PictureInfoKHR>(), offset_of!(VideoEncodeH264PictureInfoKHR, s_type), offset_of!(VideoEncodeH264PictureInfoKHR, p_next), offset_of!(VideoEncodeH264PictureInfoKHR, nalu_slice_entry_count), offset_of!(VideoEncodeH264PictureInfoKHR, p_nalu_slice_entries), offset_of!(VideoEncodeH264PictureInfoKHR, p_std_picture_info), offset_of!(VideoEncodeH264PictureInfoKHR, generate_prefix_nalu));
    println!("VideoEncodeH264ProfileInfoKHR {} {} {} {} {}", size_of::<VideoEncodeH264ProfileInfoKHR>(), align_of::<VideoEncodeH264ProfileInfoKHR>(), offset_of!(VideoEncodeH264ProfileInfoKHR, s_type), offset_of!(VideoEncodeH264ProfileInfoKHR, p_next), offset_of!(VideoEncodeH264ProfileInfoKHR, std_profile_idc));
    println!("VideoEncodeH264NaluSliceInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeH264NaluSliceInfoKHR>(), align_of::<VideoEncodeH264NaluSliceInfoKHR>(), offset_of!(VideoEncodeH264NaluSliceInfoKHR, s_type), offset_of!(VideoEncodeH264NaluSliceInfoKHR, p_next), offset_of!(VideoEncodeH264NaluSliceInfoKHR, constant_qp), offset_of!(VideoEncodeH264NaluSliceInfoKHR, p_std_slice_header));
    println!("VideoEncodeH264RateControlInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264RateControlInfoKHR>(), align_of::<VideoEncodeH264RateControlInfoKHR>(), offset_of!(VideoEncodeH264RateControlInfoKHR, s_type), offset_of!(VideoEncodeH264RateControlInfoKHR, p_next), offset_of!(VideoEncodeH264RateControlInfoKHR, flags), offset_of!(VideoEncodeH264RateControlInfoKHR, gop_frame_count), offset_of!(VideoEncodeH264RateControlInfoKHR, idr_period), offset_of!(VideoEncodeH264RateControlInfoKHR, consecutive_b_frame_count), offset_of!(VideoEncodeH264RateControlInfoKHR, temporal_layer_count));
    println!("VideoEncodeH264QpKHR {} {} {} {} {}", size_of::<VideoEncodeH264QpKHR>(), align_of::<VideoEncodeH264QpKHR>(), offset_of!(VideoEncodeH264QpKHR, qp_i), offset_of!(VideoEncodeH264QpKHR, qp_p), offset_of!(VideoEncodeH264QpKHR, qp_b));
    println!("VideoEncodeH264FrameSizeKHR {} {} {} {} {}", size_of::<VideoEncodeH264FrameSizeKHR>(), align_of::<VideoEncodeH264FrameSizeKHR>(), offset_of!(VideoEncodeH264FrameSizeKHR, frame_i_size), offset_of!(VideoEncodeH264FrameSizeKHR, frame_p_size), offset_of!(VideoEncodeH264FrameSizeKHR, frame_b_size));
    println!("VideoEncodeH264GopRemainingFrameInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264GopRemainingFrameInfoKHR>(), align_of::<VideoEncodeH264GopRemainingFrameInfoKHR>(), offset_of!(VideoEncodeH264GopRemainingFrameInfoKHR, s_type), offset_of!(VideoEncodeH264GopRemainingFrameInfoKHR, p_next), offset_of!(VideoEncodeH264GopRemainingFrameInfoKHR, use_gop_remaining_frames), offset_of!(VideoEncodeH264GopRemainingFrameInfoKHR, gop_remaining_i), offset_of!(VideoEncodeH264GopRemainingFrameInfoKHR, gop_remaining_p), offset_of!(VideoEncodeH264GopRemainingFrameInfoKHR, gop_remaining_b));
    println!("VideoEncodeH264RateControlLayerInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH264RateControlLayerInfoKHR>(), align_of::<VideoEncodeH264RateControlLayerInfoKHR>(), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, s_type), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, p_next), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, use_min_qp), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, min_qp), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, use_max_qp), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, max_qp), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, use_max_frame_size), offset_of!(VideoEncodeH264RateControlLayerInfoKHR, max_frame_size));
    println!("VideoEncodeH265CapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265CapabilitiesKHR>(), align_of::<VideoEncodeH265CapabilitiesKHR>(), offset_of!(VideoEncodeH265CapabilitiesKHR, s_type), offset_of!(VideoEncodeH265CapabilitiesKHR, p_next), offset_of!(VideoEncodeH265CapabilitiesKHR, flags), offset_of!(VideoEncodeH265CapabilitiesKHR, max_level_idc), offset_of!(VideoEncodeH265CapabilitiesKHR, max_slice_segment_count), offset_of!(VideoEncodeH265CapabilitiesKHR, max_tiles), offset_of!(VideoEncodeH265CapabilitiesKHR, ctb_sizes), offset_of!(VideoEncodeH265CapabilitiesKHR, transform_block_sizes), offset_of!(VideoEncodeH265CapabilitiesKHR, max_p_picture_l0_reference_count), offset_of!(VideoEncodeH265CapabilitiesKHR, max_b_picture_l0_reference_count), offset_of!(VideoEncodeH265CapabilitiesKHR, max_l1_reference_count), offset_of!(VideoEncodeH265CapabilitiesKHR, max_sub_layer_count), offset_of!(VideoEncodeH265CapabilitiesKHR, expect_dyadic_temporal_sub_layer_pattern), offset_of!(VideoEncodeH265CapabilitiesKHR, min_qp), offset_of!(VideoEncodeH265CapabilitiesKHR, max_qp), offset_of!(VideoEncodeH265CapabilitiesKHR, prefers_gop_remaining_frames), offset_of!(VideoEncodeH265CapabilitiesKHR, requires_gop_remaining_frames), offset_of!(VideoEncodeH265CapabilitiesKHR, std_syntax_flags));
    println!("VideoEncodeH265QualityLevelPropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265QualityLevelPropertiesKHR>(), align_of::<VideoEncodeH265QualityLevelPropertiesKHR>(), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, s_type), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, p_next), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_rate_control_flags), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_gop_frame_count), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_idr_period), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_consecutive_b_frame_count), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_sub_layer_count), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_constant_qp), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_max_l0_reference_count), offset_of!(VideoEncodeH265QualityLevelPropertiesKHR, preferred_max_l1_reference_count));
    println!("VideoEncodeH265SessionCreateInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeH265SessionCreateInfoKHR>(), align_of::<VideoEncodeH265SessionCreateInfoKHR>(), offset_of!(VideoEncodeH265SessionCreateInfoKHR, s_type), offset_of!(VideoEncodeH265SessionCreateInfoKHR, p_next), offset_of!(VideoEncodeH265SessionCreateInfoKHR, use_max_level_idc), offset_of!(VideoEncodeH265SessionCreateInfoKHR, max_level_idc));
    println!("VideoEncodeH265SessionParametersAddInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265SessionParametersAddInfoKHR>(), align_of::<VideoEncodeH265SessionParametersAddInfoKHR>(), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, s_type), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, p_next), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, std_vps_count), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, p_std_vp_ss), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, std_sps_count), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, p_std_sp_ss), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, std_pps_count), offset_of!(VideoEncodeH265SessionParametersAddInfoKHR, p_std_pp_ss));
    println!("VideoEncodeH265SessionParametersCreateInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265SessionParametersCreateInfoKHR>(), align_of::<VideoEncodeH265SessionParametersCreateInfoKHR>(), offset_of!(VideoEncodeH265SessionParametersCreateInfoKHR, s_type), offset_of!(VideoEncodeH265SessionParametersCreateInfoKHR, p_next), offset_of!(VideoEncodeH265SessionParametersCreateInfoKHR, max_std_vps_count), offset_of!(VideoEncodeH265SessionParametersCreateInfoKHR, max_std_sps_count), offset_of!(VideoEncodeH265SessionParametersCreateInfoKHR, max_std_pps_count), offset_of!(VideoEncodeH265SessionParametersCreateInfoKHR, p_parameters_add_info));
    println!("VideoEncodeH265SessionParametersGetInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265SessionParametersGetInfoKHR>(), align_of::<VideoEncodeH265SessionParametersGetInfoKHR>(), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, s_type), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, p_next), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, write_std_vps), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, write_std_sps), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, write_std_pps), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, std_vps_id), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, std_sps_id), offset_of!(VideoEncodeH265SessionParametersGetInfoKHR, std_pps_id));
    println!("VideoEncodeH265SessionParametersFeedbackInfoKHR {} {} {} {} {} {} {}", size_of::<VideoEncodeH265SessionParametersFeedbackInfoKHR>(), align_of::<VideoEncodeH265SessionParametersFeedbackInfoKHR>(), offset_of!(VideoEncodeH265SessionParametersFeedbackInfoKHR, s_type), offset_of!(VideoEncodeH265SessionParametersFeedbackInfoKHR, p_next), offset_of!(VideoEncodeH265SessionParametersFeedbackInfoKHR, has_std_vps_overrides), offset_of!(VideoEncodeH265SessionParametersFeedbackInfoKHR, has_std_sps_overrides), offset_of!(VideoEncodeH265SessionParametersFeedbackInfoKHR, has_std_pps_overrides));
    println!("VideoEncodeH265PictureInfoKHR {} {} {} {} {} {} {}", size_of::<VideoEncodeH265PictureInfoKHR>(), align_of::<VideoEncodeH265PictureInfoKHR>(), offset_of!(VideoEncodeH265PictureInfoKHR, s_type), offset_of!(VideoEncodeH265PictureInfoKHR, p_next), offset_of!(VideoEncodeH265PictureInfoKHR, nalu_slice_segment_entry_count), offset_of!(VideoEncodeH265PictureInfoKHR, p_nalu_slice_segment_entries), offset_of!(VideoEncodeH265PictureInfoKHR, p_std_picture_info));
    println!("VideoEncodeH265NaluSliceSegmentInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeH265NaluSliceSegmentInfoKHR>(), align_of::<VideoEncodeH265NaluSliceSegmentInfoKHR>(), offset_of!(VideoEncodeH265NaluSliceSegmentInfoKHR, s_type), offset_of!(VideoEncodeH265NaluSliceSegmentInfoKHR, p_next), offset_of!(VideoEncodeH265NaluSliceSegmentInfoKHR, constant_qp), offset_of!(VideoEncodeH265NaluSliceSegmentInfoKHR, p_std_slice_segment_header));
    println!("VideoEncodeH265RateControlInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265RateControlInfoKHR>(), align_of::<VideoEncodeH265RateControlInfoKHR>(), offset_of!(VideoEncodeH265RateControlInfoKHR, s_type), offset_of!(VideoEncodeH265RateControlInfoKHR, p_next), offset_of!(VideoEncodeH265RateControlInfoKHR, flags), offset_of!(VideoEncodeH265RateControlInfoKHR, gop_frame_count), offset_of!(VideoEncodeH265RateControlInfoKHR, idr_period), offset_of!(VideoEncodeH265RateControlInfoKHR, consecutive_b_frame_count), offset_of!(VideoEncodeH265RateControlInfoKHR, sub_layer_count));
    println!("VideoEncodeH265QpKHR {} {} {} {} {}", size_of::<VideoEncodeH265QpKHR>(), align_of::<VideoEncodeH265QpKHR>(), offset_of!(VideoEncodeH265QpKHR, qp_i), offset_of!(VideoEncodeH265QpKHR, qp_p), offset_of!(VideoEncodeH265QpKHR, qp_b));
    println!("VideoEncodeH265FrameSizeKHR {} {} {} {} {}", size_of::<VideoEncodeH265FrameSizeKHR>(), align_of::<VideoEncodeH265FrameSizeKHR>(), offset_of!(VideoEncodeH265FrameSizeKHR, frame_i_size), offset_of!(VideoEncodeH265FrameSizeKHR, frame_p_size), offset_of!(VideoEncodeH265FrameSizeKHR, frame_b_size));
    println!("VideoEncodeH265GopRemainingFrameInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265GopRemainingFrameInfoKHR>(), align_of::<VideoEncodeH265GopRemainingFrameInfoKHR>(), offset_of!(VideoEncodeH265GopRemainingFrameInfoKHR, s_type), offset_of!(VideoEncodeH265GopRemainingFrameInfoKHR, p_next), offset_of!(VideoEncodeH265GopRemainingFrameInfoKHR, use_gop_remaining_frames), offset_of!(VideoEncodeH265GopRemainingFrameInfoKHR, gop_remaining_i), offset_of!(VideoEncodeH265GopRemainingFrameInfoKHR, gop_remaining_p), offset_of!(VideoEncodeH265GopRemainingFrameInfoKHR, gop_remaining_b));
    println!("VideoEncodeH265RateControlLayerInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeH265RateControlLayerInfoKHR>(), align_of::<VideoEncodeH265RateControlLayerInfoKHR>(), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, s_type), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, p_next), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, use_min_qp), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, min_qp), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, use_max_qp), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, max_qp), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, use_max_frame_size), offset_of!(VideoEncodeH265RateControlLayerInfoKHR, max_frame_size));
    println!("VideoEncodeH265ProfileInfoKHR {} {} {} {} {}", size_of::<VideoEncodeH265ProfileInfoKHR>(), align_of::<VideoEncodeH265ProfileInfoKHR>(), offset_of!(VideoEncodeH265ProfileInfoKHR, s_type), offset_of!(VideoEncodeH265ProfileInfoKHR, p_next), offset_of!(VideoEncodeH265ProfileInfoKHR, std_profile_idc));
    println!("VideoEncodeH265DpbSlotInfoKHR {} {} {} {} {}", size_of::<VideoEncodeH265DpbSlotInfoKHR>(), align_of::<VideoEncodeH265DpbSlotInfoKHR>(), offset_of!(VideoEncodeH265DpbSlotInfoKHR, s_type), offset_of!(VideoEncodeH265DpbSlotInfoKHR, p_next), offset_of!(VideoEncodeH265DpbSlotInfoKHR, p_std_reference_info));
    println!("VideoEncodeAV1CapabilitiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1CapabilitiesKHR>(), align_of::<VideoEncodeAV1CapabilitiesKHR>(), offset_of!(VideoEncodeAV1CapabilitiesKHR, s_type), offset_of!(VideoEncodeAV1CapabilitiesKHR, p_next), offset_of!(VideoEncodeAV1CapabilitiesKHR, flags), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_level), offset_of!(VideoEncodeAV1CapabilitiesKHR, coded_picture_alignment), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_tiles), offset_of!(VideoEncodeAV1CapabilitiesKHR, min_tile_size), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_tile_size), offset_of!(VideoEncodeAV1CapabilitiesKHR, superblock_sizes), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_single_reference_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, single_reference_name_mask), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_unidirectional_compound_reference_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_unidirectional_compound_group1_reference_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, unidirectional_compound_reference_name_mask), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_bidirectional_compound_reference_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_bidirectional_compound_group1_reference_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_bidirectional_compound_group2_reference_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, bidirectional_compound_reference_name_mask), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_temporal_layer_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_spatial_layer_count), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_operating_points), offset_of!(VideoEncodeAV1CapabilitiesKHR, min_q_index), offset_of!(VideoEncodeAV1CapabilitiesKHR, max_q_index), offset_of!(VideoEncodeAV1CapabilitiesKHR, prefers_gop_remaining_frames), offset_of!(VideoEncodeAV1CapabilitiesKHR, requires_gop_remaining_frames), offset_of!(VideoEncodeAV1CapabilitiesKHR, std_syntax_flags));
    println!("VideoEncodeAV1QualityLevelPropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1QualityLevelPropertiesKHR>(), align_of::<VideoEncodeAV1QualityLevelPropertiesKHR>(), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, s_type), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, p_next), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_rate_control_flags), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_gop_frame_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_key_frame_period), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_consecutive_bipredictive_frame_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_temporal_layer_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_constant_q_index), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_max_single_reference_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_single_reference_name_mask), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_max_unidirectional_compound_reference_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_max_unidirectional_compound_group1_reference_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_unidirectional_compound_reference_name_mask), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_max_bidirectional_compound_reference_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_max_bidirectional_compound_group1_reference_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_max_bidirectional_compound_group2_reference_count), offset_of!(VideoEncodeAV1QualityLevelPropertiesKHR, preferred_bidirectional_compound_reference_name_mask));
    println!("PhysicalDeviceVideoEncodeAV1FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoEncodeAV1FeaturesKHR>(), align_of::<PhysicalDeviceVideoEncodeAV1FeaturesKHR>(), offset_of!(PhysicalDeviceVideoEncodeAV1FeaturesKHR, s_type), offset_of!(PhysicalDeviceVideoEncodeAV1FeaturesKHR, p_next), offset_of!(PhysicalDeviceVideoEncodeAV1FeaturesKHR, video_encode_av1));
    println!("VideoEncodeAV1SessionCreateInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeAV1SessionCreateInfoKHR>(), align_of::<VideoEncodeAV1SessionCreateInfoKHR>(), offset_of!(VideoEncodeAV1SessionCreateInfoKHR, s_type), offset_of!(VideoEncodeAV1SessionCreateInfoKHR, p_next), offset_of!(VideoEncodeAV1SessionCreateInfoKHR, use_max_level), offset_of!(VideoEncodeAV1SessionCreateInfoKHR, max_level));
    println!("VideoEncodeAV1SessionParametersCreateInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1SessionParametersCreateInfoKHR>(), align_of::<VideoEncodeAV1SessionParametersCreateInfoKHR>(), offset_of!(VideoEncodeAV1SessionParametersCreateInfoKHR, s_type), offset_of!(VideoEncodeAV1SessionParametersCreateInfoKHR, p_next), offset_of!(VideoEncodeAV1SessionParametersCreateInfoKHR, p_std_sequence_header), offset_of!(VideoEncodeAV1SessionParametersCreateInfoKHR, p_std_decoder_model_info), offset_of!(VideoEncodeAV1SessionParametersCreateInfoKHR, std_operating_point_count), offset_of!(VideoEncodeAV1SessionParametersCreateInfoKHR, p_std_operating_points));
    println!("VideoEncodeAV1DpbSlotInfoKHR {} {} {} {} {}", size_of::<VideoEncodeAV1DpbSlotInfoKHR>(), align_of::<VideoEncodeAV1DpbSlotInfoKHR>(), offset_of!(VideoEncodeAV1DpbSlotInfoKHR, s_type), offset_of!(VideoEncodeAV1DpbSlotInfoKHR, p_next), offset_of!(VideoEncodeAV1DpbSlotInfoKHR, p_std_reference_info));
    println!("VideoEncodeAV1PictureInfoKHR {} {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1PictureInfoKHR>(), align_of::<VideoEncodeAV1PictureInfoKHR>(), offset_of!(VideoEncodeAV1PictureInfoKHR, s_type), offset_of!(VideoEncodeAV1PictureInfoKHR, p_next), offset_of!(VideoEncodeAV1PictureInfoKHR, prediction_mode), offset_of!(VideoEncodeAV1PictureInfoKHR, rate_control_group), offset_of!(VideoEncodeAV1PictureInfoKHR, constant_q_index), offset_of!(VideoEncodeAV1PictureInfoKHR, p_std_picture_info), offset_of!(VideoEncodeAV1PictureInfoKHR, reference_name_slot_indices), offset_of!(VideoEncodeAV1PictureInfoKHR, primary_reference_cdf_only), offset_of!(VideoEncodeAV1PictureInfoKHR, generate_obu_extension_header));
    println!("VideoEncodeAV1ProfileInfoKHR {} {} {} {} {}", size_of::<VideoEncodeAV1ProfileInfoKHR>(), align_of::<VideoEncodeAV1ProfileInfoKHR>(), offset_of!(VideoEncodeAV1ProfileInfoKHR, s_type), offset_of!(VideoEncodeAV1ProfileInfoKHR, p_next), offset_of!(VideoEncodeAV1ProfileInfoKHR, std_profile));
    println!("VideoEncodeAV1RateControlInfoKHR {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1RateControlInfoKHR>(), align_of::<VideoEncodeAV1RateControlInfoKHR>(), offset_of!(VideoEncodeAV1RateControlInfoKHR, s_type), offset_of!(VideoEncodeAV1RateControlInfoKHR, p_next), offset_of!(VideoEncodeAV1RateControlInfoKHR, flags), offset_of!(VideoEncodeAV1RateControlInfoKHR, gop_frame_count), offset_of!(VideoEncodeAV1RateControlInfoKHR, key_frame_period), offset_of!(VideoEncodeAV1RateControlInfoKHR, consecutive_bipredictive_frame_count), offset_of!(VideoEncodeAV1RateControlInfoKHR, temporal_layer_count));
    println!("VideoEncodeAV1QIndexKHR {} {} {} {} {}", size_of::<VideoEncodeAV1QIndexKHR>(), align_of::<VideoEncodeAV1QIndexKHR>(), offset_of!(VideoEncodeAV1QIndexKHR, intra_q_index), offset_of!(VideoEncodeAV1QIndexKHR, predictive_q_index), offset_of!(VideoEncodeAV1QIndexKHR, bipredictive_q_index));
    println!("VideoEncodeAV1FrameSizeKHR {} {} {} {} {}", size_of::<VideoEncodeAV1FrameSizeKHR>(), align_of::<VideoEncodeAV1FrameSizeKHR>(), offset_of!(VideoEncodeAV1FrameSizeKHR, intra_frame_size), offset_of!(VideoEncodeAV1FrameSizeKHR, predictive_frame_size), offset_of!(VideoEncodeAV1FrameSizeKHR, bipredictive_frame_size));
    println!("VideoEncodeAV1GopRemainingFrameInfoKHR {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1GopRemainingFrameInfoKHR>(), align_of::<VideoEncodeAV1GopRemainingFrameInfoKHR>(), offset_of!(VideoEncodeAV1GopRemainingFrameInfoKHR, s_type), offset_of!(VideoEncodeAV1GopRemainingFrameInfoKHR, p_next), offset_of!(VideoEncodeAV1GopRemainingFrameInfoKHR, use_gop_remaining_frames), offset_of!(VideoEncodeAV1GopRemainingFrameInfoKHR, gop_remaining_intra), offset_of!(VideoEncodeAV1GopRemainingFrameInfoKHR, gop_remaining_predictive), offset_of!(VideoEncodeAV1GopRemainingFrameInfoKHR, gop_remaining_bipredictive));
    println!("VideoEncodeAV1RateControlLayerInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeAV1RateControlLayerInfoKHR>(), align_of::<VideoEncodeAV1RateControlLayerInfoKHR>(), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, s_type), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, p_next), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, use_min_q_index), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, min_q_index), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, use_max_q_index), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, max_q_index), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, use_max_frame_size), offset_of!(VideoEncodeAV1RateControlLayerInfoKHR, max_frame_size));
    println!("PhysicalDeviceInheritedViewportScissorFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceInheritedViewportScissorFeaturesNV>(), align_of::<PhysicalDeviceInheritedViewportScissorFeaturesNV>(), offset_of!(PhysicalDeviceInheritedViewportScissorFeaturesNV, s_type), offset_of!(PhysicalDeviceInheritedViewportScissorFeaturesNV, p_next), offset_of!(PhysicalDeviceInheritedViewportScissorFeaturesNV, inherited_viewport_scissor2_d));
    println!("CommandBufferInheritanceViewportScissorInfoNV {} {} {} {} {} {} {}", size_of::<CommandBufferInheritanceViewportScissorInfoNV>(), align_of::<CommandBufferInheritanceViewportScissorInfoNV>(), offset_of!(CommandBufferInheritanceViewportScissorInfoNV, s_type), offset_of!(CommandBufferInheritanceViewportScissorInfoNV, p_next), offset_of!(CommandBufferInheritanceViewportScissorInfoNV, viewport_scissor2_d), offset_of!(CommandBufferInheritanceViewportScissorInfoNV, viewport_depth_count), offset_of!(CommandBufferInheritanceViewportScissorInfoNV, p_viewport_depths));
    println!("PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(), align_of::<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(), offset_of!(PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, s_type), offset_of!(PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, p_next), offset_of!(PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, ycbcr2plane444_formats));
    println!("PhysicalDeviceProvokingVertexFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceProvokingVertexFeaturesEXT>(), align_of::<PhysicalDeviceProvokingVertexFeaturesEXT>(), offset_of!(PhysicalDeviceProvokingVertexFeaturesEXT, s_type), offset_of!(PhysicalDeviceProvokingVertexFeaturesEXT, p_next), offset_of!(PhysicalDeviceProvokingVertexFeaturesEXT, provoking_vertex_last), offset_of!(PhysicalDeviceProvokingVertexFeaturesEXT, transform_feedback_preserves_provoking_vertex));
    println!("PhysicalDeviceProvokingVertexPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceProvokingVertexPropertiesEXT>(), align_of::<PhysicalDeviceProvokingVertexPropertiesEXT>(), offset_of!(PhysicalDeviceProvokingVertexPropertiesEXT, s_type), offset_of!(PhysicalDeviceProvokingVertexPropertiesEXT, p_next), offset_of!(PhysicalDeviceProvokingVertexPropertiesEXT, provoking_vertex_mode_per_pipeline), offset_of!(PhysicalDeviceProvokingVertexPropertiesEXT, transform_feedback_preserves_triangle_fan_provoking_vertex));
    println!("PipelineRasterizationProvokingVertexStateCreateInfoEXT {} {} {} {} {}", size_of::<PipelineRasterizationProvokingVertexStateCreateInfoEXT>(), align_of::<PipelineRasterizationProvokingVertexStateCreateInfoEXT>(), offset_of!(PipelineRasterizationProvokingVertexStateCreateInfoEXT, s_type), offset_of!(PipelineRasterizationProvokingVertexStateCreateInfoEXT, p_next), offset_of!(PipelineRasterizationProvokingVertexStateCreateInfoEXT, provoking_vertex_mode));
    println!("VideoEncodeIntraRefreshCapabilitiesKHR {} {} {} {} {} {} {} {} {}", size_of::<VideoEncodeIntraRefreshCapabilitiesKHR>(), align_of::<VideoEncodeIntraRefreshCapabilitiesKHR>(), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, s_type), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, p_next), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, intra_refresh_modes), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, max_intra_refresh_cycle_duration), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, max_intra_refresh_active_reference_pictures), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, partition_independent_intra_refresh_regions), offset_of!(VideoEncodeIntraRefreshCapabilitiesKHR, non_rectangular_intra_refresh_regions));
    println!("VideoEncodeSessionIntraRefreshCreateInfoKHR {} {} {} {} {}", size_of::<VideoEncodeSessionIntraRefreshCreateInfoKHR>(), align_of::<VideoEncodeSessionIntraRefreshCreateInfoKHR>(), offset_of!(VideoEncodeSessionIntraRefreshCreateInfoKHR, s_type), offset_of!(VideoEncodeSessionIntraRefreshCreateInfoKHR, p_next), offset_of!(VideoEncodeSessionIntraRefreshCreateInfoKHR, intra_refresh_mode));
    println!("VideoEncodeIntraRefreshInfoKHR {} {} {} {} {} {}", size_of::<VideoEncodeIntraRefreshInfoKHR>(), align_of::<VideoEncodeIntraRefreshInfoKHR>(), offset_of!(VideoEncodeIntraRefreshInfoKHR, s_type), offset_of!(VideoEncodeIntraRefreshInfoKHR, p_next), offset_of!(VideoEncodeIntraRefreshInfoKHR, intra_refresh_cycle_duration), offset_of!(VideoEncodeIntraRefreshInfoKHR, intra_refresh_index));
    println!("VideoReferenceIntraRefreshInfoKHR {} {} {} {} {}", size_of::<VideoReferenceIntraRefreshInfoKHR>(), align_of::<VideoReferenceIntraRefreshInfoKHR>(), offset_of!(VideoReferenceIntraRefreshInfoKHR, s_type), offset_of!(VideoReferenceIntraRefreshInfoKHR, p_next), offset_of!(VideoReferenceIntraRefreshInfoKHR, dirty_intra_refresh_regions));
    println!("PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR>(), align_of::<PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR>(), offset_of!(PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, s_type), offset_of!(PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, p_next), offset_of!(PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, video_encode_intra_refresh));
    println!("CuModuleCreateInfoNVX {} {} {} {} {} {}", size_of::<CuModuleCreateInfoNVX>(), align_of::<CuModuleCreateInfoNVX>(), offset_of!(CuModuleCreateInfoNVX, s_type), offset_of!(CuModuleCreateInfoNVX, p_next), offset_of!(CuModuleCreateInfoNVX, data_size), offset_of!(CuModuleCreateInfoNVX, p_data));
    println!("CuModuleTexturingModeCreateInfoNVX {} {} {} {} {}", size_of::<CuModuleTexturingModeCreateInfoNVX>(), align_of::<CuModuleTexturingModeCreateInfoNVX>(), offset_of!(CuModuleTexturingModeCreateInfoNVX, s_type), offset_of!(CuModuleTexturingModeCreateInfoNVX, p_next), offset_of!(CuModuleTexturingModeCreateInfoNVX, use64bit_texturing));
    println!("CuFunctionCreateInfoNVX {} {} {} {} {} {}", size_of::<CuFunctionCreateInfoNVX>(), align_of::<CuFunctionCreateInfoNVX>(), offset_of!(CuFunctionCreateInfoNVX, s_type), offset_of!(CuFunctionCreateInfoNVX, p_next), offset_of!(CuFunctionCreateInfoNVX, module), offset_of!(CuFunctionCreateInfoNVX, p_name));
    println!("CuLaunchInfoNVX {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<CuLaunchInfoNVX>(), align_of::<CuLaunchInfoNVX>(), offset_of!(CuLaunchInfoNVX, s_type), offset_of!(CuLaunchInfoNVX, p_next), offset_of!(CuLaunchInfoNVX, function), offset_of!(CuLaunchInfoNVX, grid_dim_x), offset_of!(CuLaunchInfoNVX, grid_dim_y), offset_of!(CuLaunchInfoNVX, grid_dim_z), offset_of!(CuLaunchInfoNVX, block_dim_x), offset_of!(CuLaunchInfoNVX, block_dim_y), offset_of!(CuLaunchInfoNVX, block_dim_z), offset_of!(CuLaunchInfoNVX, shared_mem_bytes), offset_of!(CuLaunchInfoNVX, param_count), offset_of!(CuLaunchInfoNVX, p_params), offset_of!(CuLaunchInfoNVX, extra_count), offset_of!(CuLaunchInfoNVX, p_extras));
    println!("PhysicalDeviceDescriptorBufferFeaturesEXT {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorBufferFeaturesEXT>(), align_of::<PhysicalDeviceDescriptorBufferFeaturesEXT>(), offset_of!(PhysicalDeviceDescriptorBufferFeaturesEXT, s_type), offset_of!(PhysicalDeviceDescriptorBufferFeaturesEXT, p_next), offset_of!(PhysicalDeviceDescriptorBufferFeaturesEXT, descriptor_buffer), offset_of!(PhysicalDeviceDescriptorBufferFeaturesEXT, descriptor_buffer_capture_replay), offset_of!(PhysicalDeviceDescriptorBufferFeaturesEXT, descriptor_buffer_image_layout_ignored), offset_of!(PhysicalDeviceDescriptorBufferFeaturesEXT, descriptor_buffer_push_descriptors));
    println!("PhysicalDeviceDescriptorBufferPropertiesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorBufferPropertiesEXT>(), align_of::<PhysicalDeviceDescriptorBufferPropertiesEXT>(), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, s_type), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, p_next), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, combined_image_sampler_descriptor_single_array), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, bufferless_push_descriptors), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, allow_sampler_image_view_post_submit_creation), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, descriptor_buffer_offset_alignment), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_descriptor_buffer_bindings), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_resource_descriptor_buffer_bindings), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_sampler_descriptor_buffer_bindings), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_embedded_immutable_sampler_bindings), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_embedded_immutable_samplers), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, buffer_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, image_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, image_view_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, sampler_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, acceleration_structure_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, sampler_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, combined_image_sampler_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, sampled_image_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, storage_image_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, uniform_texel_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, robust_uniform_texel_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, storage_texel_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, robust_storage_texel_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, uniform_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, robust_uniform_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, storage_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, robust_storage_buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, input_attachment_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, acceleration_structure_descriptor_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_sampler_descriptor_buffer_range), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, max_resource_descriptor_buffer_range), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, sampler_descriptor_buffer_address_space_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, resource_descriptor_buffer_address_space_size), offset_of!(PhysicalDeviceDescriptorBufferPropertiesEXT, descriptor_buffer_address_space_size));
    println!("PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>(), align_of::<PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>(), offset_of!(PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, s_type), offset_of!(PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, p_next), offset_of!(PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, combined_image_sampler_density_map_descriptor_size));
    println!("DescriptorAddressInfoEXT {} {} {} {} {} {} {}", size_of::<DescriptorAddressInfoEXT>(), align_of::<DescriptorAddressInfoEXT>(), offset_of!(DescriptorAddressInfoEXT, s_type), offset_of!(DescriptorAddressInfoEXT, p_next), offset_of!(DescriptorAddressInfoEXT, address), offset_of!(DescriptorAddressInfoEXT, range), offset_of!(DescriptorAddressInfoEXT, format));
    println!("DescriptorBufferBindingInfoEXT {} {} {} {} {} {}", size_of::<DescriptorBufferBindingInfoEXT>(), align_of::<DescriptorBufferBindingInfoEXT>(), offset_of!(DescriptorBufferBindingInfoEXT, s_type), offset_of!(DescriptorBufferBindingInfoEXT, p_next), offset_of!(DescriptorBufferBindingInfoEXT, address), offset_of!(DescriptorBufferBindingInfoEXT, usage));
    println!("DescriptorBufferBindingPushDescriptorBufferHandleEXT {} {} {} {} {}", size_of::<DescriptorBufferBindingPushDescriptorBufferHandleEXT>(), align_of::<DescriptorBufferBindingPushDescriptorBufferHandleEXT>(), offset_of!(DescriptorBufferBindingPushDescriptorBufferHandleEXT, s_type), offset_of!(DescriptorBufferBindingPushDescriptorBufferHandleEXT, p_next), offset_of!(DescriptorBufferBindingPushDescriptorBufferHandleEXT, buffer));
    println!("DescriptorDataEXT {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorDataEXT>(), align_of::<DescriptorDataEXT>(), offset_of!(DescriptorDataEXT, p_sampler), offset_of!(DescriptorDataEXT, p_combined_image_sampler), offset_of!(DescriptorDataEXT, p_input_attachment_image), offset_of!(DescriptorDataEXT, p_sampled_image), offset_of!(DescriptorDataEXT, p_storage_image), offset_of!(DescriptorDataEXT, p_uniform_texel_buffer), offset_of!(DescriptorDataEXT, p_storage_texel_buffer), offset_of!(DescriptorDataEXT, p_uniform_buffer), offset_of!(DescriptorDataEXT, p_storage_buffer), offset_of!(DescriptorDataEXT, acceleration_structure));
    println!("DescriptorGetInfoEXT {} {} {} {} {}", size_of::<DescriptorGetInfoEXT>(), align_of::<DescriptorGetInfoEXT>(), offset_of!(DescriptorGetInfoEXT, s_type), offset_of!(DescriptorGetInfoEXT, p_next), offset_of!(DescriptorGetInfoEXT, data));
    println!("BufferCaptureDescriptorDataInfoEXT {} {} {} {} {}", size_of::<BufferCaptureDescriptorDataInfoEXT>(), align_of::<BufferCaptureDescriptorDataInfoEXT>(), offset_of!(BufferCaptureDescriptorDataInfoEXT, s_type), offset_of!(BufferCaptureDescriptorDataInfoEXT, p_next), offset_of!(BufferCaptureDescriptorDataInfoEXT, buffer));
    println!("ImageCaptureDescriptorDataInfoEXT {} {} {} {} {}", size_of::<ImageCaptureDescriptorDataInfoEXT>(), align_of::<ImageCaptureDescriptorDataInfoEXT>(), offset_of!(ImageCaptureDescriptorDataInfoEXT, s_type), offset_of!(ImageCaptureDescriptorDataInfoEXT, p_next), offset_of!(ImageCaptureDescriptorDataInfoEXT, image));
    println!("ImageViewCaptureDescriptorDataInfoEXT {} {} {} {} {}", size_of::<ImageViewCaptureDescriptorDataInfoEXT>(), align_of::<ImageViewCaptureDescriptorDataInfoEXT>(), offset_of!(ImageViewCaptureDescriptorDataInfoEXT, s_type), offset_of!(ImageViewCaptureDescriptorDataInfoEXT, p_next), offset_of!(ImageViewCaptureDescriptorDataInfoEXT, image_view));
    println!("SamplerCaptureDescriptorDataInfoEXT {} {} {} {} {}", size_of::<SamplerCaptureDescriptorDataInfoEXT>(), align_of::<SamplerCaptureDescriptorDataInfoEXT>(), offset_of!(SamplerCaptureDescriptorDataInfoEXT, s_type), offset_of!(SamplerCaptureDescriptorDataInfoEXT, p_next), offset_of!(SamplerCaptureDescriptorDataInfoEXT, sampler));
    println!("AccelerationStructureCaptureDescriptorDataInfoEXT {} {} {} {} {} {}", size_of::<AccelerationStructureCaptureDescriptorDataInfoEXT>(), align_of::<AccelerationStructureCaptureDescriptorDataInfoEXT>(), offset_of!(AccelerationStructureCaptureDescriptorDataInfoEXT, s_type), offset_of!(AccelerationStructureCaptureDescriptorDataInfoEXT, p_next), offset_of!(AccelerationStructureCaptureDescriptorDataInfoEXT, acceleration_structure), offset_of!(AccelerationStructureCaptureDescriptorDataInfoEXT, acceleration_structure_nv));
    println!("OpaqueCaptureDescriptorDataCreateInfoEXT {} {} {} {} {}", size_of::<OpaqueCaptureDescriptorDataCreateInfoEXT>(), align_of::<OpaqueCaptureDescriptorDataCreateInfoEXT>(), offset_of!(OpaqueCaptureDescriptorDataCreateInfoEXT, s_type), offset_of!(OpaqueCaptureDescriptorDataCreateInfoEXT, p_next), offset_of!(OpaqueCaptureDescriptorDataCreateInfoEXT, opaque_capture_descriptor_data));
    println!("PhysicalDeviceShaderIntegerDotProductFeatures {} {} {} {} {}", size_of::<PhysicalDeviceShaderIntegerDotProductFeatures>(), align_of::<PhysicalDeviceShaderIntegerDotProductFeatures>(), offset_of!(PhysicalDeviceShaderIntegerDotProductFeatures, s_type), offset_of!(PhysicalDeviceShaderIntegerDotProductFeatures, p_next), offset_of!(PhysicalDeviceShaderIntegerDotProductFeatures, shader_integer_dot_product));
    println!("PhysicalDeviceShaderIntegerDotProductProperties {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderIntegerDotProductProperties>(), align_of::<PhysicalDeviceShaderIntegerDotProductProperties>(), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, s_type), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, p_next), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product8_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product8_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product8_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product4x8_bit_packed_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product4x8_bit_packed_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product4x8_bit_packed_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product16_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product16_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product16_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product32_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product32_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product32_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product64_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product64_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product64_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating8_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating16_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating32_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating64_bit_signed_accelerated), offset_of!(PhysicalDeviceShaderIntegerDotProductProperties, integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated));
    println!("PhysicalDeviceDrmPropertiesEXT {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDrmPropertiesEXT>(), align_of::<PhysicalDeviceDrmPropertiesEXT>(), offset_of!(PhysicalDeviceDrmPropertiesEXT, s_type), offset_of!(PhysicalDeviceDrmPropertiesEXT, p_next), offset_of!(PhysicalDeviceDrmPropertiesEXT, has_primary), offset_of!(PhysicalDeviceDrmPropertiesEXT, has_render), offset_of!(PhysicalDeviceDrmPropertiesEXT, primary_major), offset_of!(PhysicalDeviceDrmPropertiesEXT, primary_minor), offset_of!(PhysicalDeviceDrmPropertiesEXT, render_major), offset_of!(PhysicalDeviceDrmPropertiesEXT, render_minor));
    println!("PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(), align_of::<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(), offset_of!(PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, s_type), offset_of!(PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, p_next), offset_of!(PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, fragment_shader_barycentric));
    println!("PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR>(), align_of::<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR>(), offset_of!(PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, s_type), offset_of!(PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, p_next), offset_of!(PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, tri_strip_vertex_order_independent_of_provoking_vertex));
    println!("PhysicalDeviceShaderFmaFeaturesKHR {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderFmaFeaturesKHR>(), align_of::<PhysicalDeviceShaderFmaFeaturesKHR>(), offset_of!(PhysicalDeviceShaderFmaFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderFmaFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderFmaFeaturesKHR, shader_fma_float16), offset_of!(PhysicalDeviceShaderFmaFeaturesKHR, shader_fma_float32), offset_of!(PhysicalDeviceShaderFmaFeaturesKHR, shader_fma_float64));
    println!("PhysicalDeviceRayTracingMotionBlurFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingMotionBlurFeaturesNV>(), align_of::<PhysicalDeviceRayTracingMotionBlurFeaturesNV>(), offset_of!(PhysicalDeviceRayTracingMotionBlurFeaturesNV, s_type), offset_of!(PhysicalDeviceRayTracingMotionBlurFeaturesNV, p_next), offset_of!(PhysicalDeviceRayTracingMotionBlurFeaturesNV, ray_tracing_motion_blur), offset_of!(PhysicalDeviceRayTracingMotionBlurFeaturesNV, ray_tracing_motion_blur_pipeline_trace_rays_indirect));
    println!("PhysicalDeviceRayTracingValidationFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingValidationFeaturesNV>(), align_of::<PhysicalDeviceRayTracingValidationFeaturesNV>(), offset_of!(PhysicalDeviceRayTracingValidationFeaturesNV, s_type), offset_of!(PhysicalDeviceRayTracingValidationFeaturesNV, p_next), offset_of!(PhysicalDeviceRayTracingValidationFeaturesNV, ray_tracing_validation));
    println!("PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>(), align_of::<PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>(), offset_of!(PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, s_type), offset_of!(PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, p_next), offset_of!(PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, spheres), offset_of!(PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, linear_swept_spheres));
    println!("AccelerationStructureGeometryMotionTrianglesDataNV {} {} {} {} {}", size_of::<AccelerationStructureGeometryMotionTrianglesDataNV>(), align_of::<AccelerationStructureGeometryMotionTrianglesDataNV>(), offset_of!(AccelerationStructureGeometryMotionTrianglesDataNV, s_type), offset_of!(AccelerationStructureGeometryMotionTrianglesDataNV, p_next), offset_of!(AccelerationStructureGeometryMotionTrianglesDataNV, vertex_data));
    println!("AccelerationStructureMotionInfoNV {} {} {} {} {} {}", size_of::<AccelerationStructureMotionInfoNV>(), align_of::<AccelerationStructureMotionInfoNV>(), offset_of!(AccelerationStructureMotionInfoNV, s_type), offset_of!(AccelerationStructureMotionInfoNV, p_next), offset_of!(AccelerationStructureMotionInfoNV, max_instances), offset_of!(AccelerationStructureMotionInfoNV, flags));
    println!("SRTDataNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<SRTDataNV>(), align_of::<SRTDataNV>(), offset_of!(SRTDataNV, sx), offset_of!(SRTDataNV, a), offset_of!(SRTDataNV, b), offset_of!(SRTDataNV, pvx), offset_of!(SRTDataNV, sy), offset_of!(SRTDataNV, c), offset_of!(SRTDataNV, pvy), offset_of!(SRTDataNV, sz), offset_of!(SRTDataNV, pvz), offset_of!(SRTDataNV, qx), offset_of!(SRTDataNV, qy), offset_of!(SRTDataNV, qz), offset_of!(SRTDataNV, qw), offset_of!(SRTDataNV, tx), offset_of!(SRTDataNV, ty), offset_of!(SRTDataNV, tz));
    println!("AccelerationStructureSRTMotionInstanceNV {} {}", size_of::<AccelerationStructureSRTMotionInstanceNV>(), align_of::<AccelerationStructureSRTMotionInstanceNV>());
    println!("AccelerationStructureMatrixMotionInstanceNV {} {}", size_of::<AccelerationStructureMatrixMotionInstanceNV>(), align_of::<AccelerationStructureMatrixMotionInstanceNV>());
    println!("AccelerationStructureMotionInstanceDataNV {} {} {} {} {}", size_of::<AccelerationStructureMotionInstanceDataNV>(), align_of::<AccelerationStructureMotionInstanceDataNV>(), offset_of!(AccelerationStructureMotionInstanceDataNV, static_instance), offset_of!(AccelerationStructureMotionInstanceDataNV, matrix_motion_instance), offset_of!(AccelerationStructureMotionInstanceDataNV, srt_motion_instance));
    println!("AccelerationStructureMotionInstanceNV {} {} {} {}", size_of::<AccelerationStructureMotionInstanceNV>(), align_of::<AccelerationStructureMotionInstanceNV>(), offset_of!(AccelerationStructureMotionInstanceNV, flags), offset_of!(AccelerationStructureMotionInstanceNV, data));
    println!("MemoryGetRemoteAddressInfoNV {} {} {} {} {} {}", size_of::<MemoryGetRemoteAddressInfoNV>(), align_of::<MemoryGetRemoteAddressInfoNV>(), offset_of!(MemoryGetRemoteAddressInfoNV, s_type), offset_of!(MemoryGetRemoteAddressInfoNV, p_next), offset_of!(MemoryGetRemoteAddressInfoNV, memory), offset_of!(MemoryGetRemoteAddressInfoNV, handle_type));
    println!("PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceRGBA10X6FormatsFeaturesEXT>(), align_of::<PhysicalDeviceRGBA10X6FormatsFeaturesEXT>(), offset_of!(PhysicalDeviceRGBA10X6FormatsFeaturesEXT, s_type), offset_of!(PhysicalDeviceRGBA10X6FormatsFeaturesEXT, p_next), offset_of!(PhysicalDeviceRGBA10X6FormatsFeaturesEXT, format_rgba10x6_without_y_cb_cr_sampler));
    println!("FormatProperties3 {} {} {} {} {} {} {}", size_of::<FormatProperties3>(), align_of::<FormatProperties3>(), offset_of!(FormatProperties3, s_type), offset_of!(FormatProperties3, p_next), offset_of!(FormatProperties3, linear_tiling_features), offset_of!(FormatProperties3, optimal_tiling_features), offset_of!(FormatProperties3, buffer_features));
    println!("DrmFormatModifierPropertiesList2EXT {} {} {} {} {} {}", size_of::<DrmFormatModifierPropertiesList2EXT>(), align_of::<DrmFormatModifierPropertiesList2EXT>(), offset_of!(DrmFormatModifierPropertiesList2EXT, s_type), offset_of!(DrmFormatModifierPropertiesList2EXT, p_next), offset_of!(DrmFormatModifierPropertiesList2EXT, drm_format_modifier_count), offset_of!(DrmFormatModifierPropertiesList2EXT, p_drm_format_modifier_properties));
    println!("DrmFormatModifierProperties2EXT {} {} {} {} {}", size_of::<DrmFormatModifierProperties2EXT>(), align_of::<DrmFormatModifierProperties2EXT>(), offset_of!(DrmFormatModifierProperties2EXT, drm_format_modifier), offset_of!(DrmFormatModifierProperties2EXT, drm_format_modifier_plane_count), offset_of!(DrmFormatModifierProperties2EXT, drm_format_modifier_tiling_features));
    println!("PipelineRenderingCreateInfo {} {} {} {} {} {} {} {} {}", size_of::<PipelineRenderingCreateInfo>(), align_of::<PipelineRenderingCreateInfo>(), offset_of!(PipelineRenderingCreateInfo, s_type), offset_of!(PipelineRenderingCreateInfo, p_next), offset_of!(PipelineRenderingCreateInfo, view_mask), offset_of!(PipelineRenderingCreateInfo, color_attachment_count), offset_of!(PipelineRenderingCreateInfo, p_color_attachment_formats), offset_of!(PipelineRenderingCreateInfo, depth_attachment_format), offset_of!(PipelineRenderingCreateInfo, stencil_attachment_format));
    println!("RenderingInfo {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<RenderingInfo>(), align_of::<RenderingInfo>(), offset_of!(RenderingInfo, s_type), offset_of!(RenderingInfo, p_next), offset_of!(RenderingInfo, flags), offset_of!(RenderingInfo, render_area), offset_of!(RenderingInfo, layer_count), offset_of!(RenderingInfo, view_mask), offset_of!(RenderingInfo, color_attachment_count), offset_of!(RenderingInfo, p_color_attachments), offset_of!(RenderingInfo, p_depth_attachment), offset_of!(RenderingInfo, p_stencil_attachment));
    println!("RenderingEndInfoKHR {} {} {} {}", size_of::<RenderingEndInfoKHR>(), align_of::<RenderingEndInfoKHR>(), offset_of!(RenderingEndInfoKHR, s_type), offset_of!(RenderingEndInfoKHR, p_next));
    println!("RenderingAttachmentInfo {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<RenderingAttachmentInfo>(), align_of::<RenderingAttachmentInfo>(), offset_of!(RenderingAttachmentInfo, s_type), offset_of!(RenderingAttachmentInfo, p_next), offset_of!(RenderingAttachmentInfo, image_view), offset_of!(RenderingAttachmentInfo, image_layout), offset_of!(RenderingAttachmentInfo, resolve_mode), offset_of!(RenderingAttachmentInfo, resolve_image_view), offset_of!(RenderingAttachmentInfo, resolve_image_layout), offset_of!(RenderingAttachmentInfo, load_op), offset_of!(RenderingAttachmentInfo, store_op), offset_of!(RenderingAttachmentInfo, clear_value));
    println!("RenderingFragmentShadingRateAttachmentInfoKHR {} {} {} {} {} {} {}", size_of::<RenderingFragmentShadingRateAttachmentInfoKHR>(), align_of::<RenderingFragmentShadingRateAttachmentInfoKHR>(), offset_of!(RenderingFragmentShadingRateAttachmentInfoKHR, s_type), offset_of!(RenderingFragmentShadingRateAttachmentInfoKHR, p_next), offset_of!(RenderingFragmentShadingRateAttachmentInfoKHR, image_view), offset_of!(RenderingFragmentShadingRateAttachmentInfoKHR, image_layout), offset_of!(RenderingFragmentShadingRateAttachmentInfoKHR, shading_rate_attachment_texel_size));
    println!("RenderingFragmentDensityMapAttachmentInfoEXT {} {} {} {} {} {}", size_of::<RenderingFragmentDensityMapAttachmentInfoEXT>(), align_of::<RenderingFragmentDensityMapAttachmentInfoEXT>(), offset_of!(RenderingFragmentDensityMapAttachmentInfoEXT, s_type), offset_of!(RenderingFragmentDensityMapAttachmentInfoEXT, p_next), offset_of!(RenderingFragmentDensityMapAttachmentInfoEXT, image_view), offset_of!(RenderingFragmentDensityMapAttachmentInfoEXT, image_layout));
    println!("PhysicalDeviceDynamicRenderingFeatures {} {} {} {} {}", size_of::<PhysicalDeviceDynamicRenderingFeatures>(), align_of::<PhysicalDeviceDynamicRenderingFeatures>(), offset_of!(PhysicalDeviceDynamicRenderingFeatures, s_type), offset_of!(PhysicalDeviceDynamicRenderingFeatures, p_next), offset_of!(PhysicalDeviceDynamicRenderingFeatures, dynamic_rendering));
    println!("CommandBufferInheritanceRenderingInfo {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<CommandBufferInheritanceRenderingInfo>(), align_of::<CommandBufferInheritanceRenderingInfo>(), offset_of!(CommandBufferInheritanceRenderingInfo, s_type), offset_of!(CommandBufferInheritanceRenderingInfo, p_next), offset_of!(CommandBufferInheritanceRenderingInfo, flags), offset_of!(CommandBufferInheritanceRenderingInfo, view_mask), offset_of!(CommandBufferInheritanceRenderingInfo, color_attachment_count), offset_of!(CommandBufferInheritanceRenderingInfo, color_attachment_count), offset_of!(CommandBufferInheritanceRenderingInfo, p_color_attachment_formats), offset_of!(CommandBufferInheritanceRenderingInfo, depth_attachment_format), offset_of!(CommandBufferInheritanceRenderingInfo, stencil_attachment_format), offset_of!(CommandBufferInheritanceRenderingInfo, rasterization_samples));
    println!("AttachmentSampleCountInfoAMD {} {} {} {} {} {} {}", size_of::<AttachmentSampleCountInfoAMD>(), align_of::<AttachmentSampleCountInfoAMD>(), offset_of!(AttachmentSampleCountInfoAMD, s_type), offset_of!(AttachmentSampleCountInfoAMD, p_next), offset_of!(AttachmentSampleCountInfoAMD, color_attachment_count), offset_of!(AttachmentSampleCountInfoAMD, p_color_attachment_samples), offset_of!(AttachmentSampleCountInfoAMD, depth_stencil_attachment_samples));
    println!("MultiviewPerViewAttributesInfoNVX {} {} {} {} {} {}", size_of::<MultiviewPerViewAttributesInfoNVX>(), align_of::<MultiviewPerViewAttributesInfoNVX>(), offset_of!(MultiviewPerViewAttributesInfoNVX, s_type), offset_of!(MultiviewPerViewAttributesInfoNVX, p_next), offset_of!(MultiviewPerViewAttributesInfoNVX, per_view_attributes), offset_of!(MultiviewPerViewAttributesInfoNVX, per_view_attributes_position_x_only));
    println!("PhysicalDeviceImageViewMinLodFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceImageViewMinLodFeaturesEXT>(), align_of::<PhysicalDeviceImageViewMinLodFeaturesEXT>(), offset_of!(PhysicalDeviceImageViewMinLodFeaturesEXT, s_type), offset_of!(PhysicalDeviceImageViewMinLodFeaturesEXT, p_next), offset_of!(PhysicalDeviceImageViewMinLodFeaturesEXT, min_lod));
    println!("ImageViewMinLodCreateInfoEXT {} {} {} {} {}", size_of::<ImageViewMinLodCreateInfoEXT>(), align_of::<ImageViewMinLodCreateInfoEXT>(), offset_of!(ImageViewMinLodCreateInfoEXT, s_type), offset_of!(ImageViewMinLodCreateInfoEXT, p_next), offset_of!(ImageViewMinLodCreateInfoEXT, min_lod));
    println!("PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(), align_of::<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(), offset_of!(PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, s_type), offset_of!(PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, p_next), offset_of!(PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, rasterization_order_color_attachment_access), offset_of!(PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, rasterization_order_depth_attachment_access), offset_of!(PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, rasterization_order_stencil_attachment_access));
    println!("PhysicalDeviceLinearColorAttachmentFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceLinearColorAttachmentFeaturesNV>(), align_of::<PhysicalDeviceLinearColorAttachmentFeaturesNV>(), offset_of!(PhysicalDeviceLinearColorAttachmentFeaturesNV, s_type), offset_of!(PhysicalDeviceLinearColorAttachmentFeaturesNV, p_next), offset_of!(PhysicalDeviceLinearColorAttachmentFeaturesNV, linear_color_attachment));
    println!("PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(), align_of::<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(), offset_of!(PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, s_type), offset_of!(PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, p_next), offset_of!(PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, graphics_pipeline_library));
    println!("PhysicalDevicePipelineBinaryFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePipelineBinaryFeaturesKHR>(), align_of::<PhysicalDevicePipelineBinaryFeaturesKHR>(), offset_of!(PhysicalDevicePipelineBinaryFeaturesKHR, s_type), offset_of!(PhysicalDevicePipelineBinaryFeaturesKHR, p_next), offset_of!(PhysicalDevicePipelineBinaryFeaturesKHR, pipeline_binaries));
    println!("DevicePipelineBinaryInternalCacheControlKHR {} {} {} {} {}", size_of::<DevicePipelineBinaryInternalCacheControlKHR>(), align_of::<DevicePipelineBinaryInternalCacheControlKHR>(), offset_of!(DevicePipelineBinaryInternalCacheControlKHR, s_type), offset_of!(DevicePipelineBinaryInternalCacheControlKHR, p_next), offset_of!(DevicePipelineBinaryInternalCacheControlKHR, disable_internal_cache));
    println!("PhysicalDevicePipelineBinaryPropertiesKHR {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDevicePipelineBinaryPropertiesKHR>(), align_of::<PhysicalDevicePipelineBinaryPropertiesKHR>(), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, s_type), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, p_next), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, pipeline_binary_internal_cache), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, pipeline_binary_internal_cache_control), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, pipeline_binary_prefers_internal_cache), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, pipeline_binary_precompiled_internal_cache), offset_of!(PhysicalDevicePipelineBinaryPropertiesKHR, pipeline_binary_compressed_data));
    println!("PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>(), align_of::<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>(), offset_of!(PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, s_type), offset_of!(PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, p_next), offset_of!(PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, graphics_pipeline_library_fast_linking), offset_of!(PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, graphics_pipeline_library_independent_interpolation_decoration));
    println!("GraphicsPipelineLibraryCreateInfoEXT {} {} {} {} {}", size_of::<GraphicsPipelineLibraryCreateInfoEXT>(), align_of::<GraphicsPipelineLibraryCreateInfoEXT>(), offset_of!(GraphicsPipelineLibraryCreateInfoEXT, s_type), offset_of!(GraphicsPipelineLibraryCreateInfoEXT, p_next), offset_of!(GraphicsPipelineLibraryCreateInfoEXT, flags));
    println!("PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(), align_of::<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(), offset_of!(PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, s_type), offset_of!(PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, p_next), offset_of!(PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, descriptor_set_host_mapping));
    println!("DescriptorSetBindingReferenceVALVE {} {} {} {} {} {}", size_of::<DescriptorSetBindingReferenceVALVE>(), align_of::<DescriptorSetBindingReferenceVALVE>(), offset_of!(DescriptorSetBindingReferenceVALVE, s_type), offset_of!(DescriptorSetBindingReferenceVALVE, p_next), offset_of!(DescriptorSetBindingReferenceVALVE, descriptor_set_layout), offset_of!(DescriptorSetBindingReferenceVALVE, binding));
    println!("DescriptorSetLayoutHostMappingInfoVALVE {} {} {} {} {} {}", size_of::<DescriptorSetLayoutHostMappingInfoVALVE>(), align_of::<DescriptorSetLayoutHostMappingInfoVALVE>(), offset_of!(DescriptorSetLayoutHostMappingInfoVALVE, s_type), offset_of!(DescriptorSetLayoutHostMappingInfoVALVE, p_next), offset_of!(DescriptorSetLayoutHostMappingInfoVALVE, descriptor_offset), offset_of!(DescriptorSetLayoutHostMappingInfoVALVE, descriptor_size));
    println!("PhysicalDeviceNestedCommandBufferFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceNestedCommandBufferFeaturesEXT>(), align_of::<PhysicalDeviceNestedCommandBufferFeaturesEXT>(), offset_of!(PhysicalDeviceNestedCommandBufferFeaturesEXT, s_type), offset_of!(PhysicalDeviceNestedCommandBufferFeaturesEXT, p_next), offset_of!(PhysicalDeviceNestedCommandBufferFeaturesEXT, nested_command_buffer), offset_of!(PhysicalDeviceNestedCommandBufferFeaturesEXT, nested_command_buffer_rendering), offset_of!(PhysicalDeviceNestedCommandBufferFeaturesEXT, nested_command_buffer_simultaneous_use));
    println!("PhysicalDeviceNestedCommandBufferPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceNestedCommandBufferPropertiesEXT>(), align_of::<PhysicalDeviceNestedCommandBufferPropertiesEXT>(), offset_of!(PhysicalDeviceNestedCommandBufferPropertiesEXT, s_type), offset_of!(PhysicalDeviceNestedCommandBufferPropertiesEXT, p_next), offset_of!(PhysicalDeviceNestedCommandBufferPropertiesEXT, max_command_buffer_nesting_level));
    println!("PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderModuleIdentifierFeaturesEXT>(), align_of::<PhysicalDeviceShaderModuleIdentifierFeaturesEXT>(), offset_of!(PhysicalDeviceShaderModuleIdentifierFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderModuleIdentifierFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderModuleIdentifierFeaturesEXT, shader_module_identifier));
    println!("PhysicalDeviceShaderModuleIdentifierPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderModuleIdentifierPropertiesEXT>(), align_of::<PhysicalDeviceShaderModuleIdentifierPropertiesEXT>(), offset_of!(PhysicalDeviceShaderModuleIdentifierPropertiesEXT, s_type), offset_of!(PhysicalDeviceShaderModuleIdentifierPropertiesEXT, p_next), offset_of!(PhysicalDeviceShaderModuleIdentifierPropertiesEXT, shader_module_identifier_algorithm_uuid));
    println!("PipelineShaderStageModuleIdentifierCreateInfoEXT {} {} {} {} {} {}", size_of::<PipelineShaderStageModuleIdentifierCreateInfoEXT>(), align_of::<PipelineShaderStageModuleIdentifierCreateInfoEXT>(), offset_of!(PipelineShaderStageModuleIdentifierCreateInfoEXT, s_type), offset_of!(PipelineShaderStageModuleIdentifierCreateInfoEXT, p_next), offset_of!(PipelineShaderStageModuleIdentifierCreateInfoEXT, identifier_size), offset_of!(PipelineShaderStageModuleIdentifierCreateInfoEXT, p_identifier));
    println!("ShaderModuleIdentifierEXT {} {} {} {} {} {}", size_of::<ShaderModuleIdentifierEXT>(), align_of::<ShaderModuleIdentifierEXT>(), offset_of!(ShaderModuleIdentifierEXT, s_type), offset_of!(ShaderModuleIdentifierEXT, p_next), offset_of!(ShaderModuleIdentifierEXT, identifier_size), offset_of!(ShaderModuleIdentifierEXT, identifier));
    println!("ImageCompressionControlEXT {} {} {} {} {} {} {}", size_of::<ImageCompressionControlEXT>(), align_of::<ImageCompressionControlEXT>(), offset_of!(ImageCompressionControlEXT, s_type), offset_of!(ImageCompressionControlEXT, p_next), offset_of!(ImageCompressionControlEXT, flags), offset_of!(ImageCompressionControlEXT, compression_control_plane_count), offset_of!(ImageCompressionControlEXT, p_fixed_rate_flags));
    println!("PhysicalDeviceImageCompressionControlFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceImageCompressionControlFeaturesEXT>(), align_of::<PhysicalDeviceImageCompressionControlFeaturesEXT>(), offset_of!(PhysicalDeviceImageCompressionControlFeaturesEXT, s_type), offset_of!(PhysicalDeviceImageCompressionControlFeaturesEXT, p_next), offset_of!(PhysicalDeviceImageCompressionControlFeaturesEXT, image_compression_control));
    println!("ImageCompressionPropertiesEXT {} {} {} {} {} {}", size_of::<ImageCompressionPropertiesEXT>(), align_of::<ImageCompressionPropertiesEXT>(), offset_of!(ImageCompressionPropertiesEXT, s_type), offset_of!(ImageCompressionPropertiesEXT, p_next), offset_of!(ImageCompressionPropertiesEXT, image_compression_flags), offset_of!(ImageCompressionPropertiesEXT, image_compression_fixed_rate_flags));
    println!("PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>(), align_of::<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>(), offset_of!(PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, s_type), offset_of!(PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, p_next), offset_of!(PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, image_compression_control_swapchain));
    println!("ImageSubresource2 {} {} {} {} {}", size_of::<ImageSubresource2>(), align_of::<ImageSubresource2>(), offset_of!(ImageSubresource2, s_type), offset_of!(ImageSubresource2, p_next), offset_of!(ImageSubresource2, image_subresource));
    println!("SubresourceLayout2 {} {} {} {} {}", size_of::<SubresourceLayout2>(), align_of::<SubresourceLayout2>(), offset_of!(SubresourceLayout2, s_type), offset_of!(SubresourceLayout2, p_next), offset_of!(SubresourceLayout2, subresource_layout));
    println!("RenderPassCreationControlEXT {} {} {} {} {}", size_of::<RenderPassCreationControlEXT>(), align_of::<RenderPassCreationControlEXT>(), offset_of!(RenderPassCreationControlEXT, s_type), offset_of!(RenderPassCreationControlEXT, p_next), offset_of!(RenderPassCreationControlEXT, disallow_merging));
    println!("RenderPassCreationFeedbackInfoEXT {} {} {}", size_of::<RenderPassCreationFeedbackInfoEXT>(), align_of::<RenderPassCreationFeedbackInfoEXT>(), offset_of!(RenderPassCreationFeedbackInfoEXT, post_merge_subpass_count));
    println!("RenderPassCreationFeedbackCreateInfoEXT {} {} {} {} {}", size_of::<RenderPassCreationFeedbackCreateInfoEXT>(), align_of::<RenderPassCreationFeedbackCreateInfoEXT>(), offset_of!(RenderPassCreationFeedbackCreateInfoEXT, s_type), offset_of!(RenderPassCreationFeedbackCreateInfoEXT, p_next), offset_of!(RenderPassCreationFeedbackCreateInfoEXT, p_render_pass_feedback));
    println!("RenderPassSubpassFeedbackInfoEXT {} {} {} {} {}", size_of::<RenderPassSubpassFeedbackInfoEXT>(), align_of::<RenderPassSubpassFeedbackInfoEXT>(), offset_of!(RenderPassSubpassFeedbackInfoEXT, subpass_merge_status), offset_of!(RenderPassSubpassFeedbackInfoEXT, description), offset_of!(RenderPassSubpassFeedbackInfoEXT, post_merge_index));
    println!("RenderPassSubpassFeedbackCreateInfoEXT {} {} {} {} {}", size_of::<RenderPassSubpassFeedbackCreateInfoEXT>(), align_of::<RenderPassSubpassFeedbackCreateInfoEXT>(), offset_of!(RenderPassSubpassFeedbackCreateInfoEXT, s_type), offset_of!(RenderPassSubpassFeedbackCreateInfoEXT, p_next), offset_of!(RenderPassSubpassFeedbackCreateInfoEXT, p_subpass_feedback));
    println!("PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(), align_of::<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(), offset_of!(PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, s_type), offset_of!(PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, p_next), offset_of!(PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, subpass_merge_feedback));
    println!("MicromapBuildInfoEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<MicromapBuildInfoEXT>(), align_of::<MicromapBuildInfoEXT>(), offset_of!(MicromapBuildInfoEXT, s_type), offset_of!(MicromapBuildInfoEXT, p_next), offset_of!(MicromapBuildInfoEXT, flags), offset_of!(MicromapBuildInfoEXT, mode), offset_of!(MicromapBuildInfoEXT, dst_micromap), offset_of!(MicromapBuildInfoEXT, usage_counts_count), offset_of!(MicromapBuildInfoEXT, p_usage_counts), offset_of!(MicromapBuildInfoEXT, pp_usage_counts), offset_of!(MicromapBuildInfoEXT, data), offset_of!(MicromapBuildInfoEXT, scratch_data), offset_of!(MicromapBuildInfoEXT, triangle_array), offset_of!(MicromapBuildInfoEXT, triangle_array_stride));
    println!("MicromapCreateInfoEXT {} {} {} {} {} {} {} {} {}", size_of::<MicromapCreateInfoEXT>(), align_of::<MicromapCreateInfoEXT>(), offset_of!(MicromapCreateInfoEXT, s_type), offset_of!(MicromapCreateInfoEXT, p_next), offset_of!(MicromapCreateInfoEXT, create_flags), offset_of!(MicromapCreateInfoEXT, buffer), offset_of!(MicromapCreateInfoEXT, offset), offset_of!(MicromapCreateInfoEXT, size), offset_of!(MicromapCreateInfoEXT, device_address));
    println!("MicromapVersionInfoEXT {} {} {} {} {}", size_of::<MicromapVersionInfoEXT>(), align_of::<MicromapVersionInfoEXT>(), offset_of!(MicromapVersionInfoEXT, s_type), offset_of!(MicromapVersionInfoEXT, p_next), offset_of!(MicromapVersionInfoEXT, p_version_data));
    println!("CopyMicromapInfoEXT {} {} {} {} {} {} {}", size_of::<CopyMicromapInfoEXT>(), align_of::<CopyMicromapInfoEXT>(), offset_of!(CopyMicromapInfoEXT, s_type), offset_of!(CopyMicromapInfoEXT, p_next), offset_of!(CopyMicromapInfoEXT, src), offset_of!(CopyMicromapInfoEXT, dst), offset_of!(CopyMicromapInfoEXT, mode));
    println!("CopyMicromapToMemoryInfoEXT {} {} {} {} {} {} {}", size_of::<CopyMicromapToMemoryInfoEXT>(), align_of::<CopyMicromapToMemoryInfoEXT>(), offset_of!(CopyMicromapToMemoryInfoEXT, s_type), offset_of!(CopyMicromapToMemoryInfoEXT, p_next), offset_of!(CopyMicromapToMemoryInfoEXT, src), offset_of!(CopyMicromapToMemoryInfoEXT, dst), offset_of!(CopyMicromapToMemoryInfoEXT, mode));
    println!("CopyMemoryToMicromapInfoEXT {} {} {} {} {} {} {}", size_of::<CopyMemoryToMicromapInfoEXT>(), align_of::<CopyMemoryToMicromapInfoEXT>(), offset_of!(CopyMemoryToMicromapInfoEXT, s_type), offset_of!(CopyMemoryToMicromapInfoEXT, p_next), offset_of!(CopyMemoryToMicromapInfoEXT, src), offset_of!(CopyMemoryToMicromapInfoEXT, dst), offset_of!(CopyMemoryToMicromapInfoEXT, mode));
    println!("MicromapBuildSizesInfoEXT {} {} {} {} {} {} {}", size_of::<MicromapBuildSizesInfoEXT>(), align_of::<MicromapBuildSizesInfoEXT>(), offset_of!(MicromapBuildSizesInfoEXT, s_type), offset_of!(MicromapBuildSizesInfoEXT, p_next), offset_of!(MicromapBuildSizesInfoEXT, micromap_size), offset_of!(MicromapBuildSizesInfoEXT, build_scratch_size), offset_of!(MicromapBuildSizesInfoEXT, discardable));
    println!("MicromapUsageEXT {} {} {} {} {}", size_of::<MicromapUsageEXT>(), align_of::<MicromapUsageEXT>(), offset_of!(MicromapUsageEXT, count), offset_of!(MicromapUsageEXT, subdivision_level), offset_of!(MicromapUsageEXT, format));
    println!("MicromapTriangleEXT {} {} {} {} {}", size_of::<MicromapTriangleEXT>(), align_of::<MicromapTriangleEXT>(), offset_of!(MicromapTriangleEXT, data_offset), offset_of!(MicromapTriangleEXT, subdivision_level), offset_of!(MicromapTriangleEXT, format));
    println!("PhysicalDeviceOpacityMicromapFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceOpacityMicromapFeaturesEXT>(), align_of::<PhysicalDeviceOpacityMicromapFeaturesEXT>(), offset_of!(PhysicalDeviceOpacityMicromapFeaturesEXT, s_type), offset_of!(PhysicalDeviceOpacityMicromapFeaturesEXT, p_next), offset_of!(PhysicalDeviceOpacityMicromapFeaturesEXT, micromap), offset_of!(PhysicalDeviceOpacityMicromapFeaturesEXT, micromap_capture_replay), offset_of!(PhysicalDeviceOpacityMicromapFeaturesEXT, micromap_host_commands));
    println!("PhysicalDeviceOpacityMicromapPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceOpacityMicromapPropertiesEXT>(), align_of::<PhysicalDeviceOpacityMicromapPropertiesEXT>(), offset_of!(PhysicalDeviceOpacityMicromapPropertiesEXT, s_type), offset_of!(PhysicalDeviceOpacityMicromapPropertiesEXT, p_next), offset_of!(PhysicalDeviceOpacityMicromapPropertiesEXT, max_opacity2_state_subdivision_level), offset_of!(PhysicalDeviceOpacityMicromapPropertiesEXT, max_opacity4_state_subdivision_level));
    println!("AccelerationStructureTrianglesOpacityMicromapEXT {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<AccelerationStructureTrianglesOpacityMicromapEXT>(), align_of::<AccelerationStructureTrianglesOpacityMicromapEXT>(), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, s_type), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, p_next), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, index_type), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, index_buffer), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, index_stride), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, base_triangle), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, usage_counts_count), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, p_usage_counts), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, pp_usage_counts), offset_of!(AccelerationStructureTrianglesOpacityMicromapEXT, micromap));
    println!("PipelinePropertiesIdentifierEXT {} {} {} {} {}", size_of::<PipelinePropertiesIdentifierEXT>(), align_of::<PipelinePropertiesIdentifierEXT>(), offset_of!(PipelinePropertiesIdentifierEXT, s_type), offset_of!(PipelinePropertiesIdentifierEXT, p_next), offset_of!(PipelinePropertiesIdentifierEXT, pipeline_identifier));
    println!("PhysicalDevicePipelinePropertiesFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDevicePipelinePropertiesFeaturesEXT>(), align_of::<PhysicalDevicePipelinePropertiesFeaturesEXT>(), offset_of!(PhysicalDevicePipelinePropertiesFeaturesEXT, s_type), offset_of!(PhysicalDevicePipelinePropertiesFeaturesEXT, p_next), offset_of!(PhysicalDevicePipelinePropertiesFeaturesEXT, pipeline_properties_identifier));
    println!("PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {} {} {} {} {}", size_of::<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(), align_of::<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(), offset_of!(PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, s_type), offset_of!(PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, p_next), offset_of!(PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, shader_early_and_late_fragment_tests));
    println!("ExternalMemoryAcquireUnmodifiedEXT {} {} {} {} {}", size_of::<ExternalMemoryAcquireUnmodifiedEXT>(), align_of::<ExternalMemoryAcquireUnmodifiedEXT>(), offset_of!(ExternalMemoryAcquireUnmodifiedEXT, s_type), offset_of!(ExternalMemoryAcquireUnmodifiedEXT, p_next), offset_of!(ExternalMemoryAcquireUnmodifiedEXT, acquire_unmodified_memory));
    println!("PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(), align_of::<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(), offset_of!(PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, s_type), offset_of!(PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, p_next), offset_of!(PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, non_seamless_cube_map));
    println!("PhysicalDevicePipelineRobustnessFeatures {} {} {} {} {}", size_of::<PhysicalDevicePipelineRobustnessFeatures>(), align_of::<PhysicalDevicePipelineRobustnessFeatures>(), offset_of!(PhysicalDevicePipelineRobustnessFeatures, s_type), offset_of!(PhysicalDevicePipelineRobustnessFeatures, p_next), offset_of!(PhysicalDevicePipelineRobustnessFeatures, pipeline_robustness));
    println!("PipelineRobustnessCreateInfo {} {} {} {} {} {} {} {}", size_of::<PipelineRobustnessCreateInfo>(), align_of::<PipelineRobustnessCreateInfo>(), offset_of!(PipelineRobustnessCreateInfo, s_type), offset_of!(PipelineRobustnessCreateInfo, p_next), offset_of!(PipelineRobustnessCreateInfo, storage_buffers), offset_of!(PipelineRobustnessCreateInfo, uniform_buffers), offset_of!(PipelineRobustnessCreateInfo, vertex_inputs), offset_of!(PipelineRobustnessCreateInfo, images));
    println!("PhysicalDevicePipelineRobustnessProperties {} {} {} {} {} {} {} {}", size_of::<PhysicalDevicePipelineRobustnessProperties>(), align_of::<PhysicalDevicePipelineRobustnessProperties>(), offset_of!(PhysicalDevicePipelineRobustnessProperties, s_type), offset_of!(PhysicalDevicePipelineRobustnessProperties, p_next), offset_of!(PhysicalDevicePipelineRobustnessProperties, default_robustness_storage_buffers), offset_of!(PhysicalDevicePipelineRobustnessProperties, default_robustness_uniform_buffers), offset_of!(PhysicalDevicePipelineRobustnessProperties, default_robustness_vertex_inputs), offset_of!(PhysicalDevicePipelineRobustnessProperties, default_robustness_images));
    println!("ImageViewSampleWeightCreateInfoQCOM {} {} {} {} {} {} {}", size_of::<ImageViewSampleWeightCreateInfoQCOM>(), align_of::<ImageViewSampleWeightCreateInfoQCOM>(), offset_of!(ImageViewSampleWeightCreateInfoQCOM, s_type), offset_of!(ImageViewSampleWeightCreateInfoQCOM, p_next), offset_of!(ImageViewSampleWeightCreateInfoQCOM, filter_center), offset_of!(ImageViewSampleWeightCreateInfoQCOM, filter_size), offset_of!(ImageViewSampleWeightCreateInfoQCOM, num_phases));
    println!("PhysicalDeviceImageProcessingFeaturesQCOM {} {} {} {} {} {} {}", size_of::<PhysicalDeviceImageProcessingFeaturesQCOM>(), align_of::<PhysicalDeviceImageProcessingFeaturesQCOM>(), offset_of!(PhysicalDeviceImageProcessingFeaturesQCOM, s_type), offset_of!(PhysicalDeviceImageProcessingFeaturesQCOM, p_next), offset_of!(PhysicalDeviceImageProcessingFeaturesQCOM, texture_sample_weighted), offset_of!(PhysicalDeviceImageProcessingFeaturesQCOM, texture_box_filter), offset_of!(PhysicalDeviceImageProcessingFeaturesQCOM, texture_block_match));
    println!("PhysicalDeviceImageProcessingPropertiesQCOM {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceImageProcessingPropertiesQCOM>(), align_of::<PhysicalDeviceImageProcessingPropertiesQCOM>(), offset_of!(PhysicalDeviceImageProcessingPropertiesQCOM, s_type), offset_of!(PhysicalDeviceImageProcessingPropertiesQCOM, p_next), offset_of!(PhysicalDeviceImageProcessingPropertiesQCOM, max_weight_filter_phases), offset_of!(PhysicalDeviceImageProcessingPropertiesQCOM, max_weight_filter_dimension), offset_of!(PhysicalDeviceImageProcessingPropertiesQCOM, max_block_match_region), offset_of!(PhysicalDeviceImageProcessingPropertiesQCOM, max_box_filter_block_size));
    println!("PhysicalDeviceTilePropertiesFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceTilePropertiesFeaturesQCOM>(), align_of::<PhysicalDeviceTilePropertiesFeaturesQCOM>(), offset_of!(PhysicalDeviceTilePropertiesFeaturesQCOM, s_type), offset_of!(PhysicalDeviceTilePropertiesFeaturesQCOM, p_next), offset_of!(PhysicalDeviceTilePropertiesFeaturesQCOM, tile_properties));
    println!("TilePropertiesQCOM {} {} {} {} {} {} {}", size_of::<TilePropertiesQCOM>(), align_of::<TilePropertiesQCOM>(), offset_of!(TilePropertiesQCOM, s_type), offset_of!(TilePropertiesQCOM, p_next), offset_of!(TilePropertiesQCOM, tile_size), offset_of!(TilePropertiesQCOM, apron_size), offset_of!(TilePropertiesQCOM, origin));
    println!("TileMemoryBindInfoQCOM {} {} {} {} {}", size_of::<TileMemoryBindInfoQCOM>(), align_of::<TileMemoryBindInfoQCOM>(), offset_of!(TileMemoryBindInfoQCOM, s_type), offset_of!(TileMemoryBindInfoQCOM, p_next), offset_of!(TileMemoryBindInfoQCOM, memory));
    println!("PhysicalDeviceAmigoProfilingFeaturesSEC {} {} {} {} {}", size_of::<PhysicalDeviceAmigoProfilingFeaturesSEC>(), align_of::<PhysicalDeviceAmigoProfilingFeaturesSEC>(), offset_of!(PhysicalDeviceAmigoProfilingFeaturesSEC, s_type), offset_of!(PhysicalDeviceAmigoProfilingFeaturesSEC, p_next), offset_of!(PhysicalDeviceAmigoProfilingFeaturesSEC, amigo_profiling));
    println!("AmigoProfilingSubmitInfoSEC {} {} {} {} {} {}", size_of::<AmigoProfilingSubmitInfoSEC>(), align_of::<AmigoProfilingSubmitInfoSEC>(), offset_of!(AmigoProfilingSubmitInfoSEC, s_type), offset_of!(AmigoProfilingSubmitInfoSEC, p_next), offset_of!(AmigoProfilingSubmitInfoSEC, first_draw_timestamp), offset_of!(AmigoProfilingSubmitInfoSEC, swap_buffer_timestamp));
    println!("PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(), align_of::<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(), offset_of!(PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, s_type), offset_of!(PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, p_next), offset_of!(PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, attachment_feedback_loop_layout));
    println!("AttachmentFeedbackLoopInfoEXT {} {} {} {} {}", size_of::<AttachmentFeedbackLoopInfoEXT>(), align_of::<AttachmentFeedbackLoopInfoEXT>(), offset_of!(AttachmentFeedbackLoopInfoEXT, s_type), offset_of!(AttachmentFeedbackLoopInfoEXT, p_next), offset_of!(AttachmentFeedbackLoopInfoEXT, feedback_loop_enable));
    println!("PhysicalDeviceAddressBindingReportFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceAddressBindingReportFeaturesEXT>(), align_of::<PhysicalDeviceAddressBindingReportFeaturesEXT>(), offset_of!(PhysicalDeviceAddressBindingReportFeaturesEXT, s_type), offset_of!(PhysicalDeviceAddressBindingReportFeaturesEXT, p_next), offset_of!(PhysicalDeviceAddressBindingReportFeaturesEXT, report_address_binding));
    println!("RenderingAttachmentFlagsInfoKHR {} {} {} {} {}", size_of::<RenderingAttachmentFlagsInfoKHR>(), align_of::<RenderingAttachmentFlagsInfoKHR>(), offset_of!(RenderingAttachmentFlagsInfoKHR, s_type), offset_of!(RenderingAttachmentFlagsInfoKHR, p_next), offset_of!(RenderingAttachmentFlagsInfoKHR, flags));
    println!("ResolveImageModeInfoKHR {} {} {} {} {} {} {}", size_of::<ResolveImageModeInfoKHR>(), align_of::<ResolveImageModeInfoKHR>(), offset_of!(ResolveImageModeInfoKHR, s_type), offset_of!(ResolveImageModeInfoKHR, p_next), offset_of!(ResolveImageModeInfoKHR, flags), offset_of!(ResolveImageModeInfoKHR, resolve_mode), offset_of!(ResolveImageModeInfoKHR, stencil_resolve_mode));
    println!("DeviceAddressBindingCallbackDataEXT {} {} {} {} {} {} {} {}", size_of::<DeviceAddressBindingCallbackDataEXT>(), align_of::<DeviceAddressBindingCallbackDataEXT>(), offset_of!(DeviceAddressBindingCallbackDataEXT, s_type), offset_of!(DeviceAddressBindingCallbackDataEXT, p_next), offset_of!(DeviceAddressBindingCallbackDataEXT, flags), offset_of!(DeviceAddressBindingCallbackDataEXT, base_address), offset_of!(DeviceAddressBindingCallbackDataEXT, size), offset_of!(DeviceAddressBindingCallbackDataEXT, binding_type));
    println!("PhysicalDeviceOpticalFlowFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceOpticalFlowFeaturesNV>(), align_of::<PhysicalDeviceOpticalFlowFeaturesNV>(), offset_of!(PhysicalDeviceOpticalFlowFeaturesNV, s_type), offset_of!(PhysicalDeviceOpticalFlowFeaturesNV, p_next), offset_of!(PhysicalDeviceOpticalFlowFeaturesNV, optical_flow));
    println!("PhysicalDeviceOpticalFlowPropertiesNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceOpticalFlowPropertiesNV>(), align_of::<PhysicalDeviceOpticalFlowPropertiesNV>(), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, s_type), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, p_next), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, supported_output_grid_sizes), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, supported_hint_grid_sizes), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, hint_supported), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, cost_supported), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, bidirectional_flow_supported), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, global_flow_supported), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, min_width), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, min_height), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, max_width), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, max_height), offset_of!(PhysicalDeviceOpticalFlowPropertiesNV, max_num_regions_of_interest));
    println!("OpticalFlowImageFormatInfoNV {} {} {} {} {}", size_of::<OpticalFlowImageFormatInfoNV>(), align_of::<OpticalFlowImageFormatInfoNV>(), offset_of!(OpticalFlowImageFormatInfoNV, s_type), offset_of!(OpticalFlowImageFormatInfoNV, p_next), offset_of!(OpticalFlowImageFormatInfoNV, usage));
    println!("OpticalFlowImageFormatPropertiesNV {} {} {} {} {}", size_of::<OpticalFlowImageFormatPropertiesNV>(), align_of::<OpticalFlowImageFormatPropertiesNV>(), offset_of!(OpticalFlowImageFormatPropertiesNV, s_type), offset_of!(OpticalFlowImageFormatPropertiesNV, p_next), offset_of!(OpticalFlowImageFormatPropertiesNV, format));
    println!("OpticalFlowSessionCreateInfoNV {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<OpticalFlowSessionCreateInfoNV>(), align_of::<OpticalFlowSessionCreateInfoNV>(), offset_of!(OpticalFlowSessionCreateInfoNV, s_type), offset_of!(OpticalFlowSessionCreateInfoNV, p_next), offset_of!(OpticalFlowSessionCreateInfoNV, width), offset_of!(OpticalFlowSessionCreateInfoNV, height), offset_of!(OpticalFlowSessionCreateInfoNV, image_format), offset_of!(OpticalFlowSessionCreateInfoNV, flow_vector_format), offset_of!(OpticalFlowSessionCreateInfoNV, cost_format), offset_of!(OpticalFlowSessionCreateInfoNV, output_grid_size), offset_of!(OpticalFlowSessionCreateInfoNV, hint_grid_size), offset_of!(OpticalFlowSessionCreateInfoNV, performance_level), offset_of!(OpticalFlowSessionCreateInfoNV, flags));
    println!("OpticalFlowSessionCreatePrivateDataInfoNV {} {} {} {} {} {} {}", size_of::<OpticalFlowSessionCreatePrivateDataInfoNV>(), align_of::<OpticalFlowSessionCreatePrivateDataInfoNV>(), offset_of!(OpticalFlowSessionCreatePrivateDataInfoNV, s_type), offset_of!(OpticalFlowSessionCreatePrivateDataInfoNV, p_next), offset_of!(OpticalFlowSessionCreatePrivateDataInfoNV, id), offset_of!(OpticalFlowSessionCreatePrivateDataInfoNV, size), offset_of!(OpticalFlowSessionCreatePrivateDataInfoNV, p_private_data));
    println!("OpticalFlowExecuteInfoNV {} {} {} {} {} {} {}", size_of::<OpticalFlowExecuteInfoNV>(), align_of::<OpticalFlowExecuteInfoNV>(), offset_of!(OpticalFlowExecuteInfoNV, s_type), offset_of!(OpticalFlowExecuteInfoNV, p_next), offset_of!(OpticalFlowExecuteInfoNV, flags), offset_of!(OpticalFlowExecuteInfoNV, region_count), offset_of!(OpticalFlowExecuteInfoNV, p_regions));
    println!("PhysicalDeviceFaultFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceFaultFeaturesEXT>(), align_of::<PhysicalDeviceFaultFeaturesEXT>(), offset_of!(PhysicalDeviceFaultFeaturesEXT, s_type), offset_of!(PhysicalDeviceFaultFeaturesEXT, p_next), offset_of!(PhysicalDeviceFaultFeaturesEXT, device_fault), offset_of!(PhysicalDeviceFaultFeaturesEXT, device_fault_vendor_binary));
    println!("DeviceFaultAddressInfoKHR {} {} {} {} {}", size_of::<DeviceFaultAddressInfoKHR>(), align_of::<DeviceFaultAddressInfoKHR>(), offset_of!(DeviceFaultAddressInfoKHR, address_type), offset_of!(DeviceFaultAddressInfoKHR, reported_address), offset_of!(DeviceFaultAddressInfoKHR, address_precision));
    println!("DeviceFaultVendorInfoKHR {} {} {} {} {}", size_of::<DeviceFaultVendorInfoKHR>(), align_of::<DeviceFaultVendorInfoKHR>(), offset_of!(DeviceFaultVendorInfoKHR, description), offset_of!(DeviceFaultVendorInfoKHR, vendor_fault_code), offset_of!(DeviceFaultVendorInfoKHR, vendor_fault_data));
    println!("DeviceFaultInfoKHR {} {} {} {} {} {} {} {} {} {}", size_of::<DeviceFaultInfoKHR>(), align_of::<DeviceFaultInfoKHR>(), offset_of!(DeviceFaultInfoKHR, s_type), offset_of!(DeviceFaultInfoKHR, p_next), offset_of!(DeviceFaultInfoKHR, flags), offset_of!(DeviceFaultInfoKHR, group_id), offset_of!(DeviceFaultInfoKHR, description), offset_of!(DeviceFaultInfoKHR, fault_address_info), offset_of!(DeviceFaultInfoKHR, instruction_address_info), offset_of!(DeviceFaultInfoKHR, vendor_info));
    println!("DeviceFaultDebugInfoKHR {} {} {} {} {} {}", size_of::<DeviceFaultDebugInfoKHR>(), align_of::<DeviceFaultDebugInfoKHR>(), offset_of!(DeviceFaultDebugInfoKHR, s_type), offset_of!(DeviceFaultDebugInfoKHR, p_next), offset_of!(DeviceFaultDebugInfoKHR, vendor_binary_size), offset_of!(DeviceFaultDebugInfoKHR, p_vendor_binary_data));
    println!("DeviceFaultCountsEXT {} {} {} {} {} {} {}", size_of::<DeviceFaultCountsEXT>(), align_of::<DeviceFaultCountsEXT>(), offset_of!(DeviceFaultCountsEXT, s_type), offset_of!(DeviceFaultCountsEXT, p_next), offset_of!(DeviceFaultCountsEXT, address_info_count), offset_of!(DeviceFaultCountsEXT, vendor_info_count), offset_of!(DeviceFaultCountsEXT, vendor_binary_size));
    println!("DeviceFaultInfoEXT {} {} {} {} {} {} {} {}", size_of::<DeviceFaultInfoEXT>(), align_of::<DeviceFaultInfoEXT>(), offset_of!(DeviceFaultInfoEXT, s_type), offset_of!(DeviceFaultInfoEXT, p_next), offset_of!(DeviceFaultInfoEXT, description), offset_of!(DeviceFaultInfoEXT, p_address_infos), offset_of!(DeviceFaultInfoEXT, p_vendor_infos), offset_of!(DeviceFaultInfoEXT, p_vendor_binary_data));
    println!("DeviceFaultVendorBinaryHeaderVersionOneKHR {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DeviceFaultVendorBinaryHeaderVersionOneKHR>(), align_of::<DeviceFaultVendorBinaryHeaderVersionOneKHR>(), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, header_size), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, header_version), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, vendor_id), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, device_id), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, driver_version), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, pipeline_cache_uuid), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, application_name_offset), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, application_version), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, engine_name_offset), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, engine_version), offset_of!(DeviceFaultVendorBinaryHeaderVersionOneKHR, api_version));
    println!("PhysicalDeviceFaultFeaturesKHR {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceFaultFeaturesKHR>(), align_of::<PhysicalDeviceFaultFeaturesKHR>(), offset_of!(PhysicalDeviceFaultFeaturesKHR, s_type), offset_of!(PhysicalDeviceFaultFeaturesKHR, p_next), offset_of!(PhysicalDeviceFaultFeaturesKHR, device_fault), offset_of!(PhysicalDeviceFaultFeaturesKHR, device_fault_vendor_binary), offset_of!(PhysicalDeviceFaultFeaturesKHR, device_fault_report_masked), offset_of!(PhysicalDeviceFaultFeaturesKHR, device_fault_device_lost_on_masked));
    println!("PhysicalDeviceFaultPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceFaultPropertiesKHR>(), align_of::<PhysicalDeviceFaultPropertiesKHR>(), offset_of!(PhysicalDeviceFaultPropertiesKHR, s_type), offset_of!(PhysicalDeviceFaultPropertiesKHR, p_next), offset_of!(PhysicalDeviceFaultPropertiesKHR, max_device_fault_count));
    println!("PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>(), align_of::<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>(), offset_of!(PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, s_type), offset_of!(PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, p_next), offset_of!(PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, pipeline_library_group_handles));
    println!("DepthBiasInfoEXT {} {} {} {} {} {} {}", size_of::<DepthBiasInfoEXT>(), align_of::<DepthBiasInfoEXT>(), offset_of!(DepthBiasInfoEXT, s_type), offset_of!(DepthBiasInfoEXT, p_next), offset_of!(DepthBiasInfoEXT, depth_bias_constant_factor), offset_of!(DepthBiasInfoEXT, depth_bias_clamp), offset_of!(DepthBiasInfoEXT, depth_bias_slope_factor));
    println!("DepthBiasRepresentationInfoEXT {} {} {} {} {} {}", size_of::<DepthBiasRepresentationInfoEXT>(), align_of::<DepthBiasRepresentationInfoEXT>(), offset_of!(DepthBiasRepresentationInfoEXT, s_type), offset_of!(DepthBiasRepresentationInfoEXT, p_next), offset_of!(DepthBiasRepresentationInfoEXT, depth_bias_representation), offset_of!(DepthBiasRepresentationInfoEXT, depth_bias_exact));
    println!("DecompressMemoryRegionNV {} {} {} {} {} {} {}", size_of::<DecompressMemoryRegionNV>(), align_of::<DecompressMemoryRegionNV>(), offset_of!(DecompressMemoryRegionNV, src_address), offset_of!(DecompressMemoryRegionNV, dst_address), offset_of!(DecompressMemoryRegionNV, compressed_size), offset_of!(DecompressMemoryRegionNV, decompressed_size), offset_of!(DecompressMemoryRegionNV, decompression_method));
    println!("DecompressMemoryRegionEXT {} {} {} {} {} {}", size_of::<DecompressMemoryRegionEXT>(), align_of::<DecompressMemoryRegionEXT>(), offset_of!(DecompressMemoryRegionEXT, src_address), offset_of!(DecompressMemoryRegionEXT, dst_address), offset_of!(DecompressMemoryRegionEXT, compressed_size), offset_of!(DecompressMemoryRegionEXT, decompressed_size));
    println!("DecompressMemoryInfoEXT {} {} {} {} {} {} {}", size_of::<DecompressMemoryInfoEXT>(), align_of::<DecompressMemoryInfoEXT>(), offset_of!(DecompressMemoryInfoEXT, s_type), offset_of!(DecompressMemoryInfoEXT, p_next), offset_of!(DecompressMemoryInfoEXT, decompression_method), offset_of!(DecompressMemoryInfoEXT, region_count), offset_of!(DecompressMemoryInfoEXT, p_regions));
    println!("PhysicalDeviceShaderCoreBuiltinsPropertiesARM {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderCoreBuiltinsPropertiesARM>(), align_of::<PhysicalDeviceShaderCoreBuiltinsPropertiesARM>(), offset_of!(PhysicalDeviceShaderCoreBuiltinsPropertiesARM, s_type), offset_of!(PhysicalDeviceShaderCoreBuiltinsPropertiesARM, p_next), offset_of!(PhysicalDeviceShaderCoreBuiltinsPropertiesARM, shader_core_mask), offset_of!(PhysicalDeviceShaderCoreBuiltinsPropertiesARM, shader_core_count), offset_of!(PhysicalDeviceShaderCoreBuiltinsPropertiesARM, shader_warps_per_core));
    println!("PhysicalDeviceShaderCoreBuiltinsFeaturesARM {} {} {} {} {}", size_of::<PhysicalDeviceShaderCoreBuiltinsFeaturesARM>(), align_of::<PhysicalDeviceShaderCoreBuiltinsFeaturesARM>(), offset_of!(PhysicalDeviceShaderCoreBuiltinsFeaturesARM, s_type), offset_of!(PhysicalDeviceShaderCoreBuiltinsFeaturesARM, p_next), offset_of!(PhysicalDeviceShaderCoreBuiltinsFeaturesARM, shader_core_builtins));
    println!("FrameBoundaryEXT {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<FrameBoundaryEXT>(), align_of::<FrameBoundaryEXT>(), offset_of!(FrameBoundaryEXT, s_type), offset_of!(FrameBoundaryEXT, p_next), offset_of!(FrameBoundaryEXT, flags), offset_of!(FrameBoundaryEXT, frame_id), offset_of!(FrameBoundaryEXT, image_count), offset_of!(FrameBoundaryEXT, p_images), offset_of!(FrameBoundaryEXT, buffer_count), offset_of!(FrameBoundaryEXT, p_buffers), offset_of!(FrameBoundaryEXT, tag_name), offset_of!(FrameBoundaryEXT, tag_size), offset_of!(FrameBoundaryEXT, p_tag));
    println!("PhysicalDeviceFrameBoundaryFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceFrameBoundaryFeaturesEXT>(), align_of::<PhysicalDeviceFrameBoundaryFeaturesEXT>(), offset_of!(PhysicalDeviceFrameBoundaryFeaturesEXT, s_type), offset_of!(PhysicalDeviceFrameBoundaryFeaturesEXT, p_next), offset_of!(PhysicalDeviceFrameBoundaryFeaturesEXT, frame_boundary));
    println!("PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>(), align_of::<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>(), offset_of!(PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, s_type), offset_of!(PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, p_next), offset_of!(PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, dynamic_rendering_unused_attachments));
    println!("PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>(), align_of::<PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>(), offset_of!(PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, s_type), offset_of!(PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, p_next), offset_of!(PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, internally_synchronized_queues));
    println!("SurfacePresentModeKHR {} {} {} {} {}", size_of::<SurfacePresentModeKHR>(), align_of::<SurfacePresentModeKHR>(), offset_of!(SurfacePresentModeKHR, s_type), offset_of!(SurfacePresentModeKHR, p_next), offset_of!(SurfacePresentModeKHR, present_mode));
    println!("SurfacePresentScalingCapabilitiesKHR {} {} {} {} {} {} {} {} {}", size_of::<SurfacePresentScalingCapabilitiesKHR>(), align_of::<SurfacePresentScalingCapabilitiesKHR>(), offset_of!(SurfacePresentScalingCapabilitiesKHR, s_type), offset_of!(SurfacePresentScalingCapabilitiesKHR, p_next), offset_of!(SurfacePresentScalingCapabilitiesKHR, supported_present_scaling), offset_of!(SurfacePresentScalingCapabilitiesKHR, supported_present_gravity_x), offset_of!(SurfacePresentScalingCapabilitiesKHR, supported_present_gravity_y), offset_of!(SurfacePresentScalingCapabilitiesKHR, min_scaled_image_extent), offset_of!(SurfacePresentScalingCapabilitiesKHR, max_scaled_image_extent));
    println!("SurfacePresentModeCompatibilityKHR {} {} {} {} {} {}", size_of::<SurfacePresentModeCompatibilityKHR>(), align_of::<SurfacePresentModeCompatibilityKHR>(), offset_of!(SurfacePresentModeCompatibilityKHR, s_type), offset_of!(SurfacePresentModeCompatibilityKHR, p_next), offset_of!(SurfacePresentModeCompatibilityKHR, present_mode_count), offset_of!(SurfacePresentModeCompatibilityKHR, p_present_modes));
    println!("PhysicalDeviceSwapchainMaintenance1FeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceSwapchainMaintenance1FeaturesKHR>(), align_of::<PhysicalDeviceSwapchainMaintenance1FeaturesKHR>(), offset_of!(PhysicalDeviceSwapchainMaintenance1FeaturesKHR, s_type), offset_of!(PhysicalDeviceSwapchainMaintenance1FeaturesKHR, p_next), offset_of!(PhysicalDeviceSwapchainMaintenance1FeaturesKHR, swapchain_maintenance1));
    println!("SwapchainPresentFenceInfoKHR {} {} {} {} {} {}", size_of::<SwapchainPresentFenceInfoKHR>(), align_of::<SwapchainPresentFenceInfoKHR>(), offset_of!(SwapchainPresentFenceInfoKHR, s_type), offset_of!(SwapchainPresentFenceInfoKHR, p_next), offset_of!(SwapchainPresentFenceInfoKHR, swapchain_count), offset_of!(SwapchainPresentFenceInfoKHR, p_fences));
    println!("SwapchainPresentModesCreateInfoKHR {} {} {} {} {} {}", size_of::<SwapchainPresentModesCreateInfoKHR>(), align_of::<SwapchainPresentModesCreateInfoKHR>(), offset_of!(SwapchainPresentModesCreateInfoKHR, s_type), offset_of!(SwapchainPresentModesCreateInfoKHR, p_next), offset_of!(SwapchainPresentModesCreateInfoKHR, present_mode_count), offset_of!(SwapchainPresentModesCreateInfoKHR, p_present_modes));
    println!("SwapchainPresentModeInfoKHR {} {} {} {} {} {}", size_of::<SwapchainPresentModeInfoKHR>(), align_of::<SwapchainPresentModeInfoKHR>(), offset_of!(SwapchainPresentModeInfoKHR, s_type), offset_of!(SwapchainPresentModeInfoKHR, p_next), offset_of!(SwapchainPresentModeInfoKHR, swapchain_count), offset_of!(SwapchainPresentModeInfoKHR, p_present_modes));
    println!("SwapchainPresentScalingCreateInfoKHR {} {} {} {} {} {} {}", size_of::<SwapchainPresentScalingCreateInfoKHR>(), align_of::<SwapchainPresentScalingCreateInfoKHR>(), offset_of!(SwapchainPresentScalingCreateInfoKHR, s_type), offset_of!(SwapchainPresentScalingCreateInfoKHR, p_next), offset_of!(SwapchainPresentScalingCreateInfoKHR, scaling_behavior), offset_of!(SwapchainPresentScalingCreateInfoKHR, present_gravity_x), offset_of!(SwapchainPresentScalingCreateInfoKHR, present_gravity_y));
    println!("ReleaseSwapchainImagesInfoKHR {} {} {} {} {} {} {}", size_of::<ReleaseSwapchainImagesInfoKHR>(), align_of::<ReleaseSwapchainImagesInfoKHR>(), offset_of!(ReleaseSwapchainImagesInfoKHR, s_type), offset_of!(ReleaseSwapchainImagesInfoKHR, p_next), offset_of!(ReleaseSwapchainImagesInfoKHR, swapchain), offset_of!(ReleaseSwapchainImagesInfoKHR, image_index_count), offset_of!(ReleaseSwapchainImagesInfoKHR, p_image_indices));
    println!("PhysicalDeviceDepthBiasControlFeaturesEXT {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDepthBiasControlFeaturesEXT>(), align_of::<PhysicalDeviceDepthBiasControlFeaturesEXT>(), offset_of!(PhysicalDeviceDepthBiasControlFeaturesEXT, s_type), offset_of!(PhysicalDeviceDepthBiasControlFeaturesEXT, p_next), offset_of!(PhysicalDeviceDepthBiasControlFeaturesEXT, depth_bias_control), offset_of!(PhysicalDeviceDepthBiasControlFeaturesEXT, least_representable_value_force_unorm_representation), offset_of!(PhysicalDeviceDepthBiasControlFeaturesEXT, float_representation), offset_of!(PhysicalDeviceDepthBiasControlFeaturesEXT, depth_bias_exact));
    println!("PhysicalDeviceRayTracingInvocationReorderFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingInvocationReorderFeaturesEXT>(), align_of::<PhysicalDeviceRayTracingInvocationReorderFeaturesEXT>(), offset_of!(PhysicalDeviceRayTracingInvocationReorderFeaturesEXT, s_type), offset_of!(PhysicalDeviceRayTracingInvocationReorderFeaturesEXT, p_next), offset_of!(PhysicalDeviceRayTracingInvocationReorderFeaturesEXT, ray_tracing_invocation_reorder));
    println!("PhysicalDeviceRayTracingInvocationReorderFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingInvocationReorderFeaturesNV>(), align_of::<PhysicalDeviceRayTracingInvocationReorderFeaturesNV>(), offset_of!(PhysicalDeviceRayTracingInvocationReorderFeaturesNV, s_type), offset_of!(PhysicalDeviceRayTracingInvocationReorderFeaturesNV, p_next), offset_of!(PhysicalDeviceRayTracingInvocationReorderFeaturesNV, ray_tracing_invocation_reorder));
    println!("PhysicalDeviceRayTracingInvocationReorderPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingInvocationReorderPropertiesEXT>(), align_of::<PhysicalDeviceRayTracingInvocationReorderPropertiesEXT>(), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesEXT, s_type), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesEXT, p_next), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesEXT, ray_tracing_invocation_reorder_reordering_hint), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesEXT, max_shader_binding_table_record_index));
    println!("PhysicalDeviceRayTracingInvocationReorderPropertiesNV {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingInvocationReorderPropertiesNV>(), align_of::<PhysicalDeviceRayTracingInvocationReorderPropertiesNV>(), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesNV, s_type), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesNV, p_next), offset_of!(PhysicalDeviceRayTracingInvocationReorderPropertiesNV, ray_tracing_invocation_reorder_reordering_hint));
    println!("PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>(), align_of::<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>(), offset_of!(PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, s_type), offset_of!(PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, p_next), offset_of!(PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, extended_sparse_address_space));
    println!("PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {} {} {} {} {} {} {}", size_of::<PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>(), align_of::<PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>(), offset_of!(PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, s_type), offset_of!(PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, p_next), offset_of!(PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, extended_sparse_address_space_size), offset_of!(PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, extended_sparse_image_usage_flags), offset_of!(PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, extended_sparse_buffer_usage_flags));
    println!("DirectDriverLoadingInfoLUNARG {} {} {} {} {} {}", size_of::<DirectDriverLoadingInfoLUNARG>(), align_of::<DirectDriverLoadingInfoLUNARG>(), offset_of!(DirectDriverLoadingInfoLUNARG, s_type), offset_of!(DirectDriverLoadingInfoLUNARG, p_next), offset_of!(DirectDriverLoadingInfoLUNARG, flags), offset_of!(DirectDriverLoadingInfoLUNARG, pfn_get_instance_proc_addr));
    println!("DirectDriverLoadingListLUNARG {} {} {} {} {} {} {}", size_of::<DirectDriverLoadingListLUNARG>(), align_of::<DirectDriverLoadingListLUNARG>(), offset_of!(DirectDriverLoadingListLUNARG, s_type), offset_of!(DirectDriverLoadingListLUNARG, p_next), offset_of!(DirectDriverLoadingListLUNARG, mode), offset_of!(DirectDriverLoadingListLUNARG, driver_count), offset_of!(DirectDriverLoadingListLUNARG, p_drivers));
    println!("PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(), align_of::<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(), offset_of!(PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, s_type), offset_of!(PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, p_next), offset_of!(PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, multiview_per_view_viewports));
    println!("PhysicalDeviceRayTracingPositionFetchFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceRayTracingPositionFetchFeaturesKHR>(), align_of::<PhysicalDeviceRayTracingPositionFetchFeaturesKHR>(), offset_of!(PhysicalDeviceRayTracingPositionFetchFeaturesKHR, s_type), offset_of!(PhysicalDeviceRayTracingPositionFetchFeaturesKHR, p_next), offset_of!(PhysicalDeviceRayTracingPositionFetchFeaturesKHR, ray_tracing_position_fetch));
    println!("DeviceImageSubresourceInfo {} {} {} {} {} {}", size_of::<DeviceImageSubresourceInfo>(), align_of::<DeviceImageSubresourceInfo>(), offset_of!(DeviceImageSubresourceInfo, s_type), offset_of!(DeviceImageSubresourceInfo, p_next), offset_of!(DeviceImageSubresourceInfo, p_create_info), offset_of!(DeviceImageSubresourceInfo, p_subresource));
    println!("PhysicalDeviceShaderCorePropertiesARM {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderCorePropertiesARM>(), align_of::<PhysicalDeviceShaderCorePropertiesARM>(), offset_of!(PhysicalDeviceShaderCorePropertiesARM, s_type), offset_of!(PhysicalDeviceShaderCorePropertiesARM, p_next), offset_of!(PhysicalDeviceShaderCorePropertiesARM, pixel_rate), offset_of!(PhysicalDeviceShaderCorePropertiesARM, texel_rate), offset_of!(PhysicalDeviceShaderCorePropertiesARM, fma_rate));
    println!("PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>(), align_of::<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>(), offset_of!(PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, s_type), offset_of!(PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, p_next), offset_of!(PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, multiview_per_view_render_areas));
    println!("MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {} {} {} {} {} {}", size_of::<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>(), align_of::<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>(), offset_of!(MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, s_type), offset_of!(MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, p_next), offset_of!(MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, per_view_render_area_count), offset_of!(MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, p_per_view_render_areas));
    println!("QueryLowLatencySupportNV {} {} {} {} {}", size_of::<QueryLowLatencySupportNV>(), align_of::<QueryLowLatencySupportNV>(), offset_of!(QueryLowLatencySupportNV, s_type), offset_of!(QueryLowLatencySupportNV, p_next), offset_of!(QueryLowLatencySupportNV, p_queried_low_latency_data));
    println!("MemoryMapInfo {} {} {} {} {} {} {} {}", size_of::<MemoryMapInfo>(), align_of::<MemoryMapInfo>(), offset_of!(MemoryMapInfo, s_type), offset_of!(MemoryMapInfo, p_next), offset_of!(MemoryMapInfo, flags), offset_of!(MemoryMapInfo, memory), offset_of!(MemoryMapInfo, offset), offset_of!(MemoryMapInfo, size));
    println!("MemoryUnmapInfo {} {} {} {} {} {}", size_of::<MemoryUnmapInfo>(), align_of::<MemoryUnmapInfo>(), offset_of!(MemoryUnmapInfo, s_type), offset_of!(MemoryUnmapInfo, p_next), offset_of!(MemoryUnmapInfo, flags), offset_of!(MemoryUnmapInfo, memory));
    println!("PhysicalDeviceShaderObjectFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderObjectFeaturesEXT>(), align_of::<PhysicalDeviceShaderObjectFeaturesEXT>(), offset_of!(PhysicalDeviceShaderObjectFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderObjectFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderObjectFeaturesEXT, shader_object));
    println!("PhysicalDeviceShaderObjectPropertiesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderObjectPropertiesEXT>(), align_of::<PhysicalDeviceShaderObjectPropertiesEXT>(), offset_of!(PhysicalDeviceShaderObjectPropertiesEXT, s_type), offset_of!(PhysicalDeviceShaderObjectPropertiesEXT, p_next), offset_of!(PhysicalDeviceShaderObjectPropertiesEXT, shader_binary_uuid), offset_of!(PhysicalDeviceShaderObjectPropertiesEXT, shader_binary_version));
    println!("ShaderCreateInfoEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ShaderCreateInfoEXT>(), align_of::<ShaderCreateInfoEXT>(), offset_of!(ShaderCreateInfoEXT, s_type), offset_of!(ShaderCreateInfoEXT, p_next), offset_of!(ShaderCreateInfoEXT, flags), offset_of!(ShaderCreateInfoEXT, stage), offset_of!(ShaderCreateInfoEXT, next_stage), offset_of!(ShaderCreateInfoEXT, code_type), offset_of!(ShaderCreateInfoEXT, code_size), offset_of!(ShaderCreateInfoEXT, p_code), offset_of!(ShaderCreateInfoEXT, p_name), offset_of!(ShaderCreateInfoEXT, set_layout_count), offset_of!(ShaderCreateInfoEXT, p_set_layouts), offset_of!(ShaderCreateInfoEXT, push_constant_range_count), offset_of!(ShaderCreateInfoEXT, p_push_constant_ranges), offset_of!(ShaderCreateInfoEXT, p_specialization_info));
    println!("PhysicalDeviceShaderTileImageFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderTileImageFeaturesEXT>(), align_of::<PhysicalDeviceShaderTileImageFeaturesEXT>(), offset_of!(PhysicalDeviceShaderTileImageFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderTileImageFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderTileImageFeaturesEXT, shader_tile_image_color_read_access), offset_of!(PhysicalDeviceShaderTileImageFeaturesEXT, shader_tile_image_depth_read_access), offset_of!(PhysicalDeviceShaderTileImageFeaturesEXT, shader_tile_image_stencil_read_access));
    println!("PhysicalDeviceShaderTileImagePropertiesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderTileImagePropertiesEXT>(), align_of::<PhysicalDeviceShaderTileImagePropertiesEXT>(), offset_of!(PhysicalDeviceShaderTileImagePropertiesEXT, s_type), offset_of!(PhysicalDeviceShaderTileImagePropertiesEXT, p_next), offset_of!(PhysicalDeviceShaderTileImagePropertiesEXT, shader_tile_image_coherent_read_accelerated), offset_of!(PhysicalDeviceShaderTileImagePropertiesEXT, shader_tile_image_read_sample_from_pixel_rate_invocation), offset_of!(PhysicalDeviceShaderTileImagePropertiesEXT, shader_tile_image_read_from_helper_invocation));
    println!("PhysicalDeviceCooperativeMatrixFeaturesKHR {} {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrixFeaturesKHR>(), align_of::<PhysicalDeviceCooperativeMatrixFeaturesKHR>(), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesKHR, s_type), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesKHR, p_next), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesKHR, cooperative_matrix), offset_of!(PhysicalDeviceCooperativeMatrixFeaturesKHR, cooperative_matrix_robust_buffer_access));
    println!("CooperativeMatrixPropertiesKHR {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<CooperativeMatrixPropertiesKHR>(), align_of::<CooperativeMatrixPropertiesKHR>(), offset_of!(CooperativeMatrixPropertiesKHR, s_type), offset_of!(CooperativeMatrixPropertiesKHR, p_next), offset_of!(CooperativeMatrixPropertiesKHR, m_size), offset_of!(CooperativeMatrixPropertiesKHR, n_size), offset_of!(CooperativeMatrixPropertiesKHR, k_size), offset_of!(CooperativeMatrixPropertiesKHR, a_type), offset_of!(CooperativeMatrixPropertiesKHR, b_type), offset_of!(CooperativeMatrixPropertiesKHR, c_type), offset_of!(CooperativeMatrixPropertiesKHR, result_type), offset_of!(CooperativeMatrixPropertiesKHR, saturating_accumulation), offset_of!(CooperativeMatrixPropertiesKHR, scope));
    println!("PhysicalDeviceCooperativeMatrixPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrixPropertiesKHR>(), align_of::<PhysicalDeviceCooperativeMatrixPropertiesKHR>(), offset_of!(PhysicalDeviceCooperativeMatrixPropertiesKHR, s_type), offset_of!(PhysicalDeviceCooperativeMatrixPropertiesKHR, p_next), offset_of!(PhysicalDeviceCooperativeMatrixPropertiesKHR, cooperative_matrix_supported_stages));
    println!("PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>(), align_of::<PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>(), offset_of!(PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM, s_type), offset_of!(PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM, p_next), offset_of!(PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM, cooperative_matrix_conversion));
    println!("PhysicalDeviceAntiLagFeaturesAMD {} {} {} {} {}", size_of::<PhysicalDeviceAntiLagFeaturesAMD>(), align_of::<PhysicalDeviceAntiLagFeaturesAMD>(), offset_of!(PhysicalDeviceAntiLagFeaturesAMD, s_type), offset_of!(PhysicalDeviceAntiLagFeaturesAMD, p_next), offset_of!(PhysicalDeviceAntiLagFeaturesAMD, anti_lag));
    println!("AntiLagDataAMD {} {} {} {} {} {} {}", size_of::<AntiLagDataAMD>(), align_of::<AntiLagDataAMD>(), offset_of!(AntiLagDataAMD, s_type), offset_of!(AntiLagDataAMD, p_next), offset_of!(AntiLagDataAMD, mode), offset_of!(AntiLagDataAMD, max_fps), offset_of!(AntiLagDataAMD, p_presentation_info));
    println!("AntiLagPresentationInfoAMD {} {} {} {} {} {}", size_of::<AntiLagPresentationInfoAMD>(), align_of::<AntiLagPresentationInfoAMD>(), offset_of!(AntiLagPresentationInfoAMD, s_type), offset_of!(AntiLagPresentationInfoAMD, p_next), offset_of!(AntiLagPresentationInfoAMD, stage), offset_of!(AntiLagPresentationInfoAMD, frame_index));
    println!("BindMemoryStatus {} {} {} {} {}", size_of::<BindMemoryStatus>(), align_of::<BindMemoryStatus>(), offset_of!(BindMemoryStatus, s_type), offset_of!(BindMemoryStatus, p_next), offset_of!(BindMemoryStatus, p_result));
    println!("PhysicalDeviceTileMemoryHeapFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceTileMemoryHeapFeaturesQCOM>(), align_of::<PhysicalDeviceTileMemoryHeapFeaturesQCOM>(), offset_of!(PhysicalDeviceTileMemoryHeapFeaturesQCOM, s_type), offset_of!(PhysicalDeviceTileMemoryHeapFeaturesQCOM, p_next), offset_of!(PhysicalDeviceTileMemoryHeapFeaturesQCOM, tile_memory_heap));
    println!("PhysicalDeviceTileMemoryHeapPropertiesQCOM {} {} {} {} {} {}", size_of::<PhysicalDeviceTileMemoryHeapPropertiesQCOM>(), align_of::<PhysicalDeviceTileMemoryHeapPropertiesQCOM>(), offset_of!(PhysicalDeviceTileMemoryHeapPropertiesQCOM, s_type), offset_of!(PhysicalDeviceTileMemoryHeapPropertiesQCOM, p_next), offset_of!(PhysicalDeviceTileMemoryHeapPropertiesQCOM, queue_submit_boundary), offset_of!(PhysicalDeviceTileMemoryHeapPropertiesQCOM, tile_buffer_transfers));
    println!("TileMemorySizeInfoQCOM {} {} {} {} {}", size_of::<TileMemorySizeInfoQCOM>(), align_of::<TileMemorySizeInfoQCOM>(), offset_of!(TileMemorySizeInfoQCOM, s_type), offset_of!(TileMemorySizeInfoQCOM, p_next), offset_of!(TileMemorySizeInfoQCOM, size));
    println!("TileMemoryRequirementsQCOM {} {} {} {} {} {}", size_of::<TileMemoryRequirementsQCOM>(), align_of::<TileMemoryRequirementsQCOM>(), offset_of!(TileMemoryRequirementsQCOM, s_type), offset_of!(TileMemoryRequirementsQCOM, p_next), offset_of!(TileMemoryRequirementsQCOM, size), offset_of!(TileMemoryRequirementsQCOM, alignment));
    println!("BindDescriptorSetsInfo {} {} {} {} {} {} {} {} {} {} {}", size_of::<BindDescriptorSetsInfo>(), align_of::<BindDescriptorSetsInfo>(), offset_of!(BindDescriptorSetsInfo, s_type), offset_of!(BindDescriptorSetsInfo, p_next), offset_of!(BindDescriptorSetsInfo, stage_flags), offset_of!(BindDescriptorSetsInfo, layout), offset_of!(BindDescriptorSetsInfo, first_set), offset_of!(BindDescriptorSetsInfo, descriptor_set_count), offset_of!(BindDescriptorSetsInfo, p_descriptor_sets), offset_of!(BindDescriptorSetsInfo, dynamic_offset_count), offset_of!(BindDescriptorSetsInfo, p_dynamic_offsets));
    println!("PushConstantsInfo {} {} {} {} {} {} {} {} {}", size_of::<PushConstantsInfo>(), align_of::<PushConstantsInfo>(), offset_of!(PushConstantsInfo, s_type), offset_of!(PushConstantsInfo, p_next), offset_of!(PushConstantsInfo, layout), offset_of!(PushConstantsInfo, stage_flags), offset_of!(PushConstantsInfo, offset), offset_of!(PushConstantsInfo, size), offset_of!(PushConstantsInfo, p_values));
    println!("PushDescriptorSetInfo {} {} {} {} {} {} {} {} {}", size_of::<PushDescriptorSetInfo>(), align_of::<PushDescriptorSetInfo>(), offset_of!(PushDescriptorSetInfo, s_type), offset_of!(PushDescriptorSetInfo, p_next), offset_of!(PushDescriptorSetInfo, stage_flags), offset_of!(PushDescriptorSetInfo, layout), offset_of!(PushDescriptorSetInfo, set), offset_of!(PushDescriptorSetInfo, descriptor_write_count), offset_of!(PushDescriptorSetInfo, p_descriptor_writes));
    println!("PushDescriptorSetWithTemplateInfo {} {} {} {} {} {} {} {}", size_of::<PushDescriptorSetWithTemplateInfo>(), align_of::<PushDescriptorSetWithTemplateInfo>(), offset_of!(PushDescriptorSetWithTemplateInfo, s_type), offset_of!(PushDescriptorSetWithTemplateInfo, p_next), offset_of!(PushDescriptorSetWithTemplateInfo, descriptor_update_template), offset_of!(PushDescriptorSetWithTemplateInfo, layout), offset_of!(PushDescriptorSetWithTemplateInfo, set), offset_of!(PushDescriptorSetWithTemplateInfo, p_data));
    println!("SetDescriptorBufferOffsetsInfoEXT {} {} {} {} {} {} {} {} {} {}", size_of::<SetDescriptorBufferOffsetsInfoEXT>(), align_of::<SetDescriptorBufferOffsetsInfoEXT>(), offset_of!(SetDescriptorBufferOffsetsInfoEXT, s_type), offset_of!(SetDescriptorBufferOffsetsInfoEXT, p_next), offset_of!(SetDescriptorBufferOffsetsInfoEXT, stage_flags), offset_of!(SetDescriptorBufferOffsetsInfoEXT, layout), offset_of!(SetDescriptorBufferOffsetsInfoEXT, first_set), offset_of!(SetDescriptorBufferOffsetsInfoEXT, set_count), offset_of!(SetDescriptorBufferOffsetsInfoEXT, p_buffer_indices), offset_of!(SetDescriptorBufferOffsetsInfoEXT, p_offsets));
    println!("BindDescriptorBufferEmbeddedSamplersInfoEXT {} {} {} {} {} {} {}", size_of::<BindDescriptorBufferEmbeddedSamplersInfoEXT>(), align_of::<BindDescriptorBufferEmbeddedSamplersInfoEXT>(), offset_of!(BindDescriptorBufferEmbeddedSamplersInfoEXT, s_type), offset_of!(BindDescriptorBufferEmbeddedSamplersInfoEXT, p_next), offset_of!(BindDescriptorBufferEmbeddedSamplersInfoEXT, stage_flags), offset_of!(BindDescriptorBufferEmbeddedSamplersInfoEXT, layout), offset_of!(BindDescriptorBufferEmbeddedSamplersInfoEXT, set));
    println!("PhysicalDeviceCubicClampFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceCubicClampFeaturesQCOM>(), align_of::<PhysicalDeviceCubicClampFeaturesQCOM>(), offset_of!(PhysicalDeviceCubicClampFeaturesQCOM, s_type), offset_of!(PhysicalDeviceCubicClampFeaturesQCOM, p_next), offset_of!(PhysicalDeviceCubicClampFeaturesQCOM, cubic_range_clamp));
    println!("PhysicalDeviceYcbcrDegammaFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceYcbcrDegammaFeaturesQCOM>(), align_of::<PhysicalDeviceYcbcrDegammaFeaturesQCOM>(), offset_of!(PhysicalDeviceYcbcrDegammaFeaturesQCOM, s_type), offset_of!(PhysicalDeviceYcbcrDegammaFeaturesQCOM, p_next), offset_of!(PhysicalDeviceYcbcrDegammaFeaturesQCOM, ycbcr_degamma));
    println!("SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {} {} {} {} {} {}", size_of::<SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>(), align_of::<SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>(), offset_of!(SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, s_type), offset_of!(SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, p_next), offset_of!(SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, enable_y_degamma), offset_of!(SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, enable_cb_cr_degamma));
    println!("PhysicalDeviceCubicWeightsFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceCubicWeightsFeaturesQCOM>(), align_of::<PhysicalDeviceCubicWeightsFeaturesQCOM>(), offset_of!(PhysicalDeviceCubicWeightsFeaturesQCOM, s_type), offset_of!(PhysicalDeviceCubicWeightsFeaturesQCOM, p_next), offset_of!(PhysicalDeviceCubicWeightsFeaturesQCOM, selectable_cubic_weights));
    println!("SamplerCubicWeightsCreateInfoQCOM {} {} {} {} {}", size_of::<SamplerCubicWeightsCreateInfoQCOM>(), align_of::<SamplerCubicWeightsCreateInfoQCOM>(), offset_of!(SamplerCubicWeightsCreateInfoQCOM, s_type), offset_of!(SamplerCubicWeightsCreateInfoQCOM, p_next), offset_of!(SamplerCubicWeightsCreateInfoQCOM, cubic_weights));
    println!("BlitImageCubicWeightsInfoQCOM {} {} {} {} {}", size_of::<BlitImageCubicWeightsInfoQCOM>(), align_of::<BlitImageCubicWeightsInfoQCOM>(), offset_of!(BlitImageCubicWeightsInfoQCOM, s_type), offset_of!(BlitImageCubicWeightsInfoQCOM, p_next), offset_of!(BlitImageCubicWeightsInfoQCOM, cubic_weights));
    println!("PhysicalDeviceImageProcessing2FeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceImageProcessing2FeaturesQCOM>(), align_of::<PhysicalDeviceImageProcessing2FeaturesQCOM>(), offset_of!(PhysicalDeviceImageProcessing2FeaturesQCOM, s_type), offset_of!(PhysicalDeviceImageProcessing2FeaturesQCOM, p_next), offset_of!(PhysicalDeviceImageProcessing2FeaturesQCOM, texture_block_match2));
    println!("PhysicalDeviceImageProcessing2PropertiesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceImageProcessing2PropertiesQCOM>(), align_of::<PhysicalDeviceImageProcessing2PropertiesQCOM>(), offset_of!(PhysicalDeviceImageProcessing2PropertiesQCOM, s_type), offset_of!(PhysicalDeviceImageProcessing2PropertiesQCOM, p_next), offset_of!(PhysicalDeviceImageProcessing2PropertiesQCOM, max_block_match_window));
    println!("SamplerBlockMatchWindowCreateInfoQCOM {} {} {} {} {} {}", size_of::<SamplerBlockMatchWindowCreateInfoQCOM>(), align_of::<SamplerBlockMatchWindowCreateInfoQCOM>(), offset_of!(SamplerBlockMatchWindowCreateInfoQCOM, s_type), offset_of!(SamplerBlockMatchWindowCreateInfoQCOM, p_next), offset_of!(SamplerBlockMatchWindowCreateInfoQCOM, window_extent), offset_of!(SamplerBlockMatchWindowCreateInfoQCOM, window_compare_mode));
    println!("PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>(), align_of::<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>(), offset_of!(PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, s_type), offset_of!(PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, p_next), offset_of!(PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, descriptor_pool_overallocation));
    println!("PhysicalDeviceLayeredDriverPropertiesMSFT {} {} {} {} {}", size_of::<PhysicalDeviceLayeredDriverPropertiesMSFT>(), align_of::<PhysicalDeviceLayeredDriverPropertiesMSFT>(), offset_of!(PhysicalDeviceLayeredDriverPropertiesMSFT, s_type), offset_of!(PhysicalDeviceLayeredDriverPropertiesMSFT, p_next), offset_of!(PhysicalDeviceLayeredDriverPropertiesMSFT, underlying_api));
    println!("PhysicalDevicePerStageDescriptorSetFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDevicePerStageDescriptorSetFeaturesNV>(), align_of::<PhysicalDevicePerStageDescriptorSetFeaturesNV>(), offset_of!(PhysicalDevicePerStageDescriptorSetFeaturesNV, s_type), offset_of!(PhysicalDevicePerStageDescriptorSetFeaturesNV, p_next), offset_of!(PhysicalDevicePerStageDescriptorSetFeaturesNV, per_stage_descriptor_set), offset_of!(PhysicalDevicePerStageDescriptorSetFeaturesNV, dynamic_pipeline_layout));
    println!("LatencySleepModeInfoNV {} {} {} {} {} {} {}", size_of::<LatencySleepModeInfoNV>(), align_of::<LatencySleepModeInfoNV>(), offset_of!(LatencySleepModeInfoNV, s_type), offset_of!(LatencySleepModeInfoNV, p_next), offset_of!(LatencySleepModeInfoNV, low_latency_mode), offset_of!(LatencySleepModeInfoNV, low_latency_boost), offset_of!(LatencySleepModeInfoNV, minimum_interval_us));
    println!("LatencySleepInfoNV {} {} {} {} {} {}", size_of::<LatencySleepInfoNV>(), align_of::<LatencySleepInfoNV>(), offset_of!(LatencySleepInfoNV, s_type), offset_of!(LatencySleepInfoNV, p_next), offset_of!(LatencySleepInfoNV, signal_semaphore), offset_of!(LatencySleepInfoNV, value));
    println!("SetLatencyMarkerInfoNV {} {} {} {} {} {}", size_of::<SetLatencyMarkerInfoNV>(), align_of::<SetLatencyMarkerInfoNV>(), offset_of!(SetLatencyMarkerInfoNV, s_type), offset_of!(SetLatencyMarkerInfoNV, p_next), offset_of!(SetLatencyMarkerInfoNV, present_id), offset_of!(SetLatencyMarkerInfoNV, marker));
    println!("GetLatencyMarkerInfoNV {} {} {} {} {} {}", size_of::<GetLatencyMarkerInfoNV>(), align_of::<GetLatencyMarkerInfoNV>(), offset_of!(GetLatencyMarkerInfoNV, s_type), offset_of!(GetLatencyMarkerInfoNV, p_next), offset_of!(GetLatencyMarkerInfoNV, timing_count), offset_of!(GetLatencyMarkerInfoNV, p_timings));
    println!("LatencyTimingsFrameReportNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<LatencyTimingsFrameReportNV>(), align_of::<LatencyTimingsFrameReportNV>(), offset_of!(LatencyTimingsFrameReportNV, s_type), offset_of!(LatencyTimingsFrameReportNV, p_next), offset_of!(LatencyTimingsFrameReportNV, present_id), offset_of!(LatencyTimingsFrameReportNV, input_sample_time_us), offset_of!(LatencyTimingsFrameReportNV, sim_start_time_us), offset_of!(LatencyTimingsFrameReportNV, sim_end_time_us), offset_of!(LatencyTimingsFrameReportNV, render_submit_start_time_us), offset_of!(LatencyTimingsFrameReportNV, render_submit_end_time_us), offset_of!(LatencyTimingsFrameReportNV, present_start_time_us), offset_of!(LatencyTimingsFrameReportNV, present_end_time_us), offset_of!(LatencyTimingsFrameReportNV, driver_start_time_us), offset_of!(LatencyTimingsFrameReportNV, driver_end_time_us), offset_of!(LatencyTimingsFrameReportNV, os_render_queue_start_time_us), offset_of!(LatencyTimingsFrameReportNV, os_render_queue_end_time_us), offset_of!(LatencyTimingsFrameReportNV, gpu_render_start_time_us), offset_of!(LatencyTimingsFrameReportNV, gpu_render_end_time_us));
    println!("OutOfBandQueueTypeInfoNV {} {} {} {} {}", size_of::<OutOfBandQueueTypeInfoNV>(), align_of::<OutOfBandQueueTypeInfoNV>(), offset_of!(OutOfBandQueueTypeInfoNV, s_type), offset_of!(OutOfBandQueueTypeInfoNV, p_next), offset_of!(OutOfBandQueueTypeInfoNV, queue_type));
    println!("LatencySubmissionPresentIdNV {} {} {} {} {}", size_of::<LatencySubmissionPresentIdNV>(), align_of::<LatencySubmissionPresentIdNV>(), offset_of!(LatencySubmissionPresentIdNV, s_type), offset_of!(LatencySubmissionPresentIdNV, p_next), offset_of!(LatencySubmissionPresentIdNV, present_id));
    println!("SwapchainLatencyCreateInfoNV {} {} {} {} {}", size_of::<SwapchainLatencyCreateInfoNV>(), align_of::<SwapchainLatencyCreateInfoNV>(), offset_of!(SwapchainLatencyCreateInfoNV, s_type), offset_of!(SwapchainLatencyCreateInfoNV, p_next), offset_of!(SwapchainLatencyCreateInfoNV, latency_mode_enable));
    println!("LatencySurfaceCapabilitiesNV {} {} {} {} {} {}", size_of::<LatencySurfaceCapabilitiesNV>(), align_of::<LatencySurfaceCapabilitiesNV>(), offset_of!(LatencySurfaceCapabilitiesNV, s_type), offset_of!(LatencySurfaceCapabilitiesNV, p_next), offset_of!(LatencySurfaceCapabilitiesNV, present_mode_count), offset_of!(LatencySurfaceCapabilitiesNV, p_present_modes));
    println!("DeviceQueueShaderCoreControlCreateInfoARM {} {} {} {} {}", size_of::<DeviceQueueShaderCoreControlCreateInfoARM>(), align_of::<DeviceQueueShaderCoreControlCreateInfoARM>(), offset_of!(DeviceQueueShaderCoreControlCreateInfoARM, s_type), offset_of!(DeviceQueueShaderCoreControlCreateInfoARM, p_next), offset_of!(DeviceQueueShaderCoreControlCreateInfoARM, shader_core_count));
    println!("PhysicalDeviceSchedulingControlsFeaturesARM {} {} {} {} {}", size_of::<PhysicalDeviceSchedulingControlsFeaturesARM>(), align_of::<PhysicalDeviceSchedulingControlsFeaturesARM>(), offset_of!(PhysicalDeviceSchedulingControlsFeaturesARM, s_type), offset_of!(PhysicalDeviceSchedulingControlsFeaturesARM, p_next), offset_of!(PhysicalDeviceSchedulingControlsFeaturesARM, scheduling_controls));
    println!("PhysicalDeviceSchedulingControlsPropertiesARM {} {} {} {} {}", size_of::<PhysicalDeviceSchedulingControlsPropertiesARM>(), align_of::<PhysicalDeviceSchedulingControlsPropertiesARM>(), offset_of!(PhysicalDeviceSchedulingControlsPropertiesARM, s_type), offset_of!(PhysicalDeviceSchedulingControlsPropertiesARM, p_next), offset_of!(PhysicalDeviceSchedulingControlsPropertiesARM, scheduling_controls_flags));
    println!("PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {} {} {} {} {}", size_of::<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>(), align_of::<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>(), offset_of!(PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, s_type), offset_of!(PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, p_next), offset_of!(PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, relaxed_line_rasterization));
    println!("PhysicalDeviceRenderPassStripedFeaturesARM {} {} {} {} {}", size_of::<PhysicalDeviceRenderPassStripedFeaturesARM>(), align_of::<PhysicalDeviceRenderPassStripedFeaturesARM>(), offset_of!(PhysicalDeviceRenderPassStripedFeaturesARM, s_type), offset_of!(PhysicalDeviceRenderPassStripedFeaturesARM, p_next), offset_of!(PhysicalDeviceRenderPassStripedFeaturesARM, render_pass_striped));
    println!("PhysicalDeviceRenderPassStripedPropertiesARM {} {} {} {} {} {}", size_of::<PhysicalDeviceRenderPassStripedPropertiesARM>(), align_of::<PhysicalDeviceRenderPassStripedPropertiesARM>(), offset_of!(PhysicalDeviceRenderPassStripedPropertiesARM, s_type), offset_of!(PhysicalDeviceRenderPassStripedPropertiesARM, p_next), offset_of!(PhysicalDeviceRenderPassStripedPropertiesARM, render_pass_stripe_granularity), offset_of!(PhysicalDeviceRenderPassStripedPropertiesARM, max_render_pass_stripes));
    println!("RenderPassStripeInfoARM {} {} {} {} {}", size_of::<RenderPassStripeInfoARM>(), align_of::<RenderPassStripeInfoARM>(), offset_of!(RenderPassStripeInfoARM, s_type), offset_of!(RenderPassStripeInfoARM, p_next), offset_of!(RenderPassStripeInfoARM, stripe_area));
    println!("RenderPassStripeBeginInfoARM {} {} {} {} {} {}", size_of::<RenderPassStripeBeginInfoARM>(), align_of::<RenderPassStripeBeginInfoARM>(), offset_of!(RenderPassStripeBeginInfoARM, s_type), offset_of!(RenderPassStripeBeginInfoARM, p_next), offset_of!(RenderPassStripeBeginInfoARM, stripe_info_count), offset_of!(RenderPassStripeBeginInfoARM, p_stripe_infos));
    println!("RenderPassStripeSubmitInfoARM {} {} {} {} {} {}", size_of::<RenderPassStripeSubmitInfoARM>(), align_of::<RenderPassStripeSubmitInfoARM>(), offset_of!(RenderPassStripeSubmitInfoARM, s_type), offset_of!(RenderPassStripeSubmitInfoARM, p_next), offset_of!(RenderPassStripeSubmitInfoARM, stripe_semaphore_info_count), offset_of!(RenderPassStripeSubmitInfoARM, p_stripe_semaphore_infos));
    println!("PhysicalDevicePipelineOpacityMicromapFeaturesARM {} {} {} {} {}", size_of::<PhysicalDevicePipelineOpacityMicromapFeaturesARM>(), align_of::<PhysicalDevicePipelineOpacityMicromapFeaturesARM>(), offset_of!(PhysicalDevicePipelineOpacityMicromapFeaturesARM, s_type), offset_of!(PhysicalDevicePipelineOpacityMicromapFeaturesARM, p_next), offset_of!(PhysicalDevicePipelineOpacityMicromapFeaturesARM, pipeline_opacity_micromap));
    println!("PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>(), align_of::<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>(), offset_of!(PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, shader_maximal_reconvergence));
    println!("PhysicalDeviceShaderSubgroupRotateFeatures {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderSubgroupRotateFeatures>(), align_of::<PhysicalDeviceShaderSubgroupRotateFeatures>(), offset_of!(PhysicalDeviceShaderSubgroupRotateFeatures, s_type), offset_of!(PhysicalDeviceShaderSubgroupRotateFeatures, p_next), offset_of!(PhysicalDeviceShaderSubgroupRotateFeatures, shader_subgroup_rotate), offset_of!(PhysicalDeviceShaderSubgroupRotateFeatures, shader_subgroup_rotate_clustered));
    println!("PhysicalDeviceShaderExpectAssumeFeatures {} {} {} {} {}", size_of::<PhysicalDeviceShaderExpectAssumeFeatures>(), align_of::<PhysicalDeviceShaderExpectAssumeFeatures>(), offset_of!(PhysicalDeviceShaderExpectAssumeFeatures, s_type), offset_of!(PhysicalDeviceShaderExpectAssumeFeatures, p_next), offset_of!(PhysicalDeviceShaderExpectAssumeFeatures, shader_expect_assume));
    println!("PhysicalDeviceShaderFloatControls2Features {} {} {} {} {}", size_of::<PhysicalDeviceShaderFloatControls2Features>(), align_of::<PhysicalDeviceShaderFloatControls2Features>(), offset_of!(PhysicalDeviceShaderFloatControls2Features, s_type), offset_of!(PhysicalDeviceShaderFloatControls2Features, p_next), offset_of!(PhysicalDeviceShaderFloatControls2Features, shader_float_controls2));
    println!("PhysicalDeviceDynamicRenderingLocalReadFeatures {} {} {} {} {}", size_of::<PhysicalDeviceDynamicRenderingLocalReadFeatures>(), align_of::<PhysicalDeviceDynamicRenderingLocalReadFeatures>(), offset_of!(PhysicalDeviceDynamicRenderingLocalReadFeatures, s_type), offset_of!(PhysicalDeviceDynamicRenderingLocalReadFeatures, p_next), offset_of!(PhysicalDeviceDynamicRenderingLocalReadFeatures, dynamic_rendering_local_read));
    println!("RenderingAttachmentLocationInfo {} {} {} {} {} {}", size_of::<RenderingAttachmentLocationInfo>(), align_of::<RenderingAttachmentLocationInfo>(), offset_of!(RenderingAttachmentLocationInfo, s_type), offset_of!(RenderingAttachmentLocationInfo, p_next), offset_of!(RenderingAttachmentLocationInfo, color_attachment_count), offset_of!(RenderingAttachmentLocationInfo, p_color_attachment_locations));
    println!("RenderingInputAttachmentIndexInfo {} {} {} {} {} {} {} {}", size_of::<RenderingInputAttachmentIndexInfo>(), align_of::<RenderingInputAttachmentIndexInfo>(), offset_of!(RenderingInputAttachmentIndexInfo, s_type), offset_of!(RenderingInputAttachmentIndexInfo, p_next), offset_of!(RenderingInputAttachmentIndexInfo, color_attachment_count), offset_of!(RenderingInputAttachmentIndexInfo, p_color_attachment_input_indices), offset_of!(RenderingInputAttachmentIndexInfo, p_depth_input_attachment_index), offset_of!(RenderingInputAttachmentIndexInfo, p_stencil_input_attachment_index));
    println!("PhysicalDeviceShaderQuadControlFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderQuadControlFeaturesKHR>(), align_of::<PhysicalDeviceShaderQuadControlFeaturesKHR>(), offset_of!(PhysicalDeviceShaderQuadControlFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderQuadControlFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderQuadControlFeaturesKHR, shader_quad_control));
    println!("PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>(), align_of::<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>(), offset_of!(PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, s_type), offset_of!(PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, p_next), offset_of!(PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, shader_float16_vector_atomics));
    println!("PhysicalDeviceMapMemoryPlacedFeaturesEXT {} {} {} {} {} {} {}", size_of::<PhysicalDeviceMapMemoryPlacedFeaturesEXT>(), align_of::<PhysicalDeviceMapMemoryPlacedFeaturesEXT>(), offset_of!(PhysicalDeviceMapMemoryPlacedFeaturesEXT, s_type), offset_of!(PhysicalDeviceMapMemoryPlacedFeaturesEXT, p_next), offset_of!(PhysicalDeviceMapMemoryPlacedFeaturesEXT, memory_map_placed), offset_of!(PhysicalDeviceMapMemoryPlacedFeaturesEXT, memory_map_range_placed), offset_of!(PhysicalDeviceMapMemoryPlacedFeaturesEXT, memory_unmap_reserve));
    println!("PhysicalDeviceMapMemoryPlacedPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceMapMemoryPlacedPropertiesEXT>(), align_of::<PhysicalDeviceMapMemoryPlacedPropertiesEXT>(), offset_of!(PhysicalDeviceMapMemoryPlacedPropertiesEXT, s_type), offset_of!(PhysicalDeviceMapMemoryPlacedPropertiesEXT, p_next), offset_of!(PhysicalDeviceMapMemoryPlacedPropertiesEXT, min_placed_memory_map_alignment));
    println!("MemoryMapPlacedInfoEXT {} {} {} {} {}", size_of::<MemoryMapPlacedInfoEXT>(), align_of::<MemoryMapPlacedInfoEXT>(), offset_of!(MemoryMapPlacedInfoEXT, s_type), offset_of!(MemoryMapPlacedInfoEXT, p_next), offset_of!(MemoryMapPlacedInfoEXT, p_placed_address));
    println!("PhysicalDeviceShaderBfloat16FeaturesKHR {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderBfloat16FeaturesKHR>(), align_of::<PhysicalDeviceShaderBfloat16FeaturesKHR>(), offset_of!(PhysicalDeviceShaderBfloat16FeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderBfloat16FeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderBfloat16FeaturesKHR, shader_b_float16_type), offset_of!(PhysicalDeviceShaderBfloat16FeaturesKHR, shader_b_float16_dot_product), offset_of!(PhysicalDeviceShaderBfloat16FeaturesKHR, shader_b_float16_cooperative_matrix));
    println!("PhysicalDeviceRawAccessChainsFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceRawAccessChainsFeaturesNV>(), align_of::<PhysicalDeviceRawAccessChainsFeaturesNV>(), offset_of!(PhysicalDeviceRawAccessChainsFeaturesNV, s_type), offset_of!(PhysicalDeviceRawAccessChainsFeaturesNV, p_next), offset_of!(PhysicalDeviceRawAccessChainsFeaturesNV, shader_raw_access_chains));
    println!("PhysicalDeviceCommandBufferInheritanceFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceCommandBufferInheritanceFeaturesNV>(), align_of::<PhysicalDeviceCommandBufferInheritanceFeaturesNV>(), offset_of!(PhysicalDeviceCommandBufferInheritanceFeaturesNV, s_type), offset_of!(PhysicalDeviceCommandBufferInheritanceFeaturesNV, p_next), offset_of!(PhysicalDeviceCommandBufferInheritanceFeaturesNV, command_buffer_inheritance));
    println!("PhysicalDeviceImageAlignmentControlFeaturesMESA {} {} {} {} {}", size_of::<PhysicalDeviceImageAlignmentControlFeaturesMESA>(), align_of::<PhysicalDeviceImageAlignmentControlFeaturesMESA>(), offset_of!(PhysicalDeviceImageAlignmentControlFeaturesMESA, s_type), offset_of!(PhysicalDeviceImageAlignmentControlFeaturesMESA, p_next), offset_of!(PhysicalDeviceImageAlignmentControlFeaturesMESA, image_alignment_control));
    println!("PhysicalDeviceImageAlignmentControlPropertiesMESA {} {} {} {} {}", size_of::<PhysicalDeviceImageAlignmentControlPropertiesMESA>(), align_of::<PhysicalDeviceImageAlignmentControlPropertiesMESA>(), offset_of!(PhysicalDeviceImageAlignmentControlPropertiesMESA, s_type), offset_of!(PhysicalDeviceImageAlignmentControlPropertiesMESA, p_next), offset_of!(PhysicalDeviceImageAlignmentControlPropertiesMESA, supported_image_alignment_mask));
    println!("ImageAlignmentControlCreateInfoMESA {} {} {} {} {}", size_of::<ImageAlignmentControlCreateInfoMESA>(), align_of::<ImageAlignmentControlCreateInfoMESA>(), offset_of!(ImageAlignmentControlCreateInfoMESA, s_type), offset_of!(ImageAlignmentControlCreateInfoMESA, p_next), offset_of!(ImageAlignmentControlCreateInfoMESA, maximum_requested_alignment));
    println!("PhysicalDeviceShaderReplicatedCompositesFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderReplicatedCompositesFeaturesEXT>(), align_of::<PhysicalDeviceShaderReplicatedCompositesFeaturesEXT>(), offset_of!(PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, shader_replicated_composites));
    println!("PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>(), align_of::<PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>(), offset_of!(PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, s_type), offset_of!(PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, p_next), offset_of!(PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, present_mode_fifo_latest_ready));
    println!("DepthClampRangeEXT {} {} {} {}", size_of::<DepthClampRangeEXT>(), align_of::<DepthClampRangeEXT>(), offset_of!(DepthClampRangeEXT, min_depth_clamp), offset_of!(DepthClampRangeEXT, max_depth_clamp));
    println!("PhysicalDeviceCooperativeMatrix2FeaturesNV {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrix2FeaturesNV>(), align_of::<PhysicalDeviceCooperativeMatrix2FeaturesNV>(), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, s_type), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, p_next), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_workgroup_scope), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_flexible_dimensions), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_reductions), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_conversions), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_per_element_operations), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_tensor_addressing), offset_of!(PhysicalDeviceCooperativeMatrix2FeaturesNV, cooperative_matrix_block_loads));
    println!("PhysicalDeviceCooperativeMatrix2PropertiesNV {} {} {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeMatrix2PropertiesNV>(), align_of::<PhysicalDeviceCooperativeMatrix2PropertiesNV>(), offset_of!(PhysicalDeviceCooperativeMatrix2PropertiesNV, s_type), offset_of!(PhysicalDeviceCooperativeMatrix2PropertiesNV, p_next), offset_of!(PhysicalDeviceCooperativeMatrix2PropertiesNV, cooperative_matrix_workgroup_scope_max_workgroup_size), offset_of!(PhysicalDeviceCooperativeMatrix2PropertiesNV, cooperative_matrix_flexible_dimensions_max_dimension), offset_of!(PhysicalDeviceCooperativeMatrix2PropertiesNV, cooperative_matrix_workgroup_scope_reserved_shared_memory));
    println!("CooperativeMatrixFlexibleDimensionsPropertiesNV {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<CooperativeMatrixFlexibleDimensionsPropertiesNV>(), align_of::<CooperativeMatrixFlexibleDimensionsPropertiesNV>(), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, s_type), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, p_next), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, m_granularity), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, n_granularity), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, k_granularity), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, a_type), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, b_type), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, c_type), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, result_type), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, saturating_accumulation), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, scope), offset_of!(CooperativeMatrixFlexibleDimensionsPropertiesNV, workgroup_invocations));
    println!("PhysicalDeviceHdrVividFeaturesHUAWEI {} {} {} {} {}", size_of::<PhysicalDeviceHdrVividFeaturesHUAWEI>(), align_of::<PhysicalDeviceHdrVividFeaturesHUAWEI>(), offset_of!(PhysicalDeviceHdrVividFeaturesHUAWEI, s_type), offset_of!(PhysicalDeviceHdrVividFeaturesHUAWEI, p_next), offset_of!(PhysicalDeviceHdrVividFeaturesHUAWEI, hdr_vivid));
    println!("PhysicalDeviceVertexAttributeRobustnessFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>(), align_of::<PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>(), offset_of!(PhysicalDeviceVertexAttributeRobustnessFeaturesEXT, s_type), offset_of!(PhysicalDeviceVertexAttributeRobustnessFeaturesEXT, p_next), offset_of!(PhysicalDeviceVertexAttributeRobustnessFeaturesEXT, vertex_attribute_robustness));
    println!("PhysicalDeviceDepthClampZeroOneFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceDepthClampZeroOneFeaturesKHR>(), align_of::<PhysicalDeviceDepthClampZeroOneFeaturesKHR>(), offset_of!(PhysicalDeviceDepthClampZeroOneFeaturesKHR, s_type), offset_of!(PhysicalDeviceDepthClampZeroOneFeaturesKHR, p_next), offset_of!(PhysicalDeviceDepthClampZeroOneFeaturesKHR, depth_clamp_zero_one));
    println!("PhysicalDeviceCooperativeVectorFeaturesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeVectorFeaturesNV>(), align_of::<PhysicalDeviceCooperativeVectorFeaturesNV>(), offset_of!(PhysicalDeviceCooperativeVectorFeaturesNV, s_type), offset_of!(PhysicalDeviceCooperativeVectorFeaturesNV, p_next), offset_of!(PhysicalDeviceCooperativeVectorFeaturesNV, cooperative_vector), offset_of!(PhysicalDeviceCooperativeVectorFeaturesNV, cooperative_vector_training));
    println!("CooperativeVectorPropertiesNV {} {} {} {} {} {} {} {} {} {}", size_of::<CooperativeVectorPropertiesNV>(), align_of::<CooperativeVectorPropertiesNV>(), offset_of!(CooperativeVectorPropertiesNV, s_type), offset_of!(CooperativeVectorPropertiesNV, p_next), offset_of!(CooperativeVectorPropertiesNV, input_type), offset_of!(CooperativeVectorPropertiesNV, input_interpretation), offset_of!(CooperativeVectorPropertiesNV, matrix_interpretation), offset_of!(CooperativeVectorPropertiesNV, bias_interpretation), offset_of!(CooperativeVectorPropertiesNV, result_type), offset_of!(CooperativeVectorPropertiesNV, transpose));
    println!("PhysicalDeviceCooperativeVectorPropertiesNV {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceCooperativeVectorPropertiesNV>(), align_of::<PhysicalDeviceCooperativeVectorPropertiesNV>(), offset_of!(PhysicalDeviceCooperativeVectorPropertiesNV, s_type), offset_of!(PhysicalDeviceCooperativeVectorPropertiesNV, p_next), offset_of!(PhysicalDeviceCooperativeVectorPropertiesNV, cooperative_vector_supported_stages), offset_of!(PhysicalDeviceCooperativeVectorPropertiesNV, cooperative_vector_training_float16_accumulation), offset_of!(PhysicalDeviceCooperativeVectorPropertiesNV, cooperative_vector_training_float32_accumulation), offset_of!(PhysicalDeviceCooperativeVectorPropertiesNV, max_cooperative_vector_components));
    println!("ConvertCooperativeVectorMatrixInfoNV {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<ConvertCooperativeVectorMatrixInfoNV>(), align_of::<ConvertCooperativeVectorMatrixInfoNV>(), offset_of!(ConvertCooperativeVectorMatrixInfoNV, s_type), offset_of!(ConvertCooperativeVectorMatrixInfoNV, p_next), offset_of!(ConvertCooperativeVectorMatrixInfoNV, src_size), offset_of!(ConvertCooperativeVectorMatrixInfoNV, src_data), offset_of!(ConvertCooperativeVectorMatrixInfoNV, p_dst_size), offset_of!(ConvertCooperativeVectorMatrixInfoNV, dst_data), offset_of!(ConvertCooperativeVectorMatrixInfoNV, src_component_type), offset_of!(ConvertCooperativeVectorMatrixInfoNV, dst_component_type), offset_of!(ConvertCooperativeVectorMatrixInfoNV, num_rows), offset_of!(ConvertCooperativeVectorMatrixInfoNV, num_columns), offset_of!(ConvertCooperativeVectorMatrixInfoNV, src_layout), offset_of!(ConvertCooperativeVectorMatrixInfoNV, src_stride), offset_of!(ConvertCooperativeVectorMatrixInfoNV, dst_layout), offset_of!(ConvertCooperativeVectorMatrixInfoNV, dst_stride));
    println!("PhysicalDeviceTileShadingFeaturesQCOM {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceTileShadingFeaturesQCOM>(), align_of::<PhysicalDeviceTileShadingFeaturesQCOM>(), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, s_type), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, p_next), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_fragment_stage), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_color_attachments), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_depth_attachments), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_stencil_attachments), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_input_attachments), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_sampled_attachments), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_per_tile_draw), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_per_tile_dispatch), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_dispatch_tile), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_apron), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_anisotropic_apron), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_atomic_ops), offset_of!(PhysicalDeviceTileShadingFeaturesQCOM, tile_shading_image_processing));
    println!("PhysicalDeviceTileShadingPropertiesQCOM {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceTileShadingPropertiesQCOM>(), align_of::<PhysicalDeviceTileShadingPropertiesQCOM>(), offset_of!(PhysicalDeviceTileShadingPropertiesQCOM, s_type), offset_of!(PhysicalDeviceTileShadingPropertiesQCOM, p_next), offset_of!(PhysicalDeviceTileShadingPropertiesQCOM, max_apron_size), offset_of!(PhysicalDeviceTileShadingPropertiesQCOM, prefer_non_coherent), offset_of!(PhysicalDeviceTileShadingPropertiesQCOM, tile_granularity), offset_of!(PhysicalDeviceTileShadingPropertiesQCOM, max_tile_shading_rate));
    println!("RenderPassTileShadingCreateInfoQCOM {} {} {} {} {} {}", size_of::<RenderPassTileShadingCreateInfoQCOM>(), align_of::<RenderPassTileShadingCreateInfoQCOM>(), offset_of!(RenderPassTileShadingCreateInfoQCOM, s_type), offset_of!(RenderPassTileShadingCreateInfoQCOM, p_next), offset_of!(RenderPassTileShadingCreateInfoQCOM, flags), offset_of!(RenderPassTileShadingCreateInfoQCOM, tile_apron_size));
    println!("PerTileBeginInfoQCOM {} {} {} {}", size_of::<PerTileBeginInfoQCOM>(), align_of::<PerTileBeginInfoQCOM>(), offset_of!(PerTileBeginInfoQCOM, s_type), offset_of!(PerTileBeginInfoQCOM, p_next));
    println!("PerTileEndInfoQCOM {} {} {} {}", size_of::<PerTileEndInfoQCOM>(), align_of::<PerTileEndInfoQCOM>(), offset_of!(PerTileEndInfoQCOM, s_type), offset_of!(PerTileEndInfoQCOM, p_next));
    println!("DispatchTileInfoQCOM {} {} {} {}", size_of::<DispatchTileInfoQCOM>(), align_of::<DispatchTileInfoQCOM>(), offset_of!(DispatchTileInfoQCOM, s_type), offset_of!(DispatchTileInfoQCOM, p_next));
    println!("PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>(), align_of::<PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>(), offset_of!(PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, s_type), offset_of!(PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, p_next), offset_of!(PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, max_fragment_density_map_layers));
    println!("PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {} {} {} {} {}", size_of::<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>(), align_of::<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>(), offset_of!(PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, s_type), offset_of!(PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, p_next), offset_of!(PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, fragment_density_map_layered));
    println!("PipelineFragmentDensityMapLayeredCreateInfoVALVE {} {} {} {} {}", size_of::<PipelineFragmentDensityMapLayeredCreateInfoVALVE>(), align_of::<PipelineFragmentDensityMapLayeredCreateInfoVALVE>(), offset_of!(PipelineFragmentDensityMapLayeredCreateInfoVALVE, s_type), offset_of!(PipelineFragmentDensityMapLayeredCreateInfoVALVE, p_next), offset_of!(PipelineFragmentDensityMapLayeredCreateInfoVALVE, max_fragment_density_map_layers));
    println!("SetPresentConfigNV {} {} {} {} {} {}", size_of::<SetPresentConfigNV>(), align_of::<SetPresentConfigNV>(), offset_of!(SetPresentConfigNV, s_type), offset_of!(SetPresentConfigNV, p_next), offset_of!(SetPresentConfigNV, num_frames_per_batch), offset_of!(SetPresentConfigNV, present_config_feedback));
    println!("PhysicalDevicePresentMeteringFeaturesNV {} {} {} {} {}", size_of::<PhysicalDevicePresentMeteringFeaturesNV>(), align_of::<PhysicalDevicePresentMeteringFeaturesNV>(), offset_of!(PhysicalDevicePresentMeteringFeaturesNV, s_type), offset_of!(PhysicalDevicePresentMeteringFeaturesNV, p_next), offset_of!(PhysicalDevicePresentMeteringFeaturesNV, present_metering));
    println!("ExternalComputeQueueDeviceCreateInfoNV {} {} {} {} {}", size_of::<ExternalComputeQueueDeviceCreateInfoNV>(), align_of::<ExternalComputeQueueDeviceCreateInfoNV>(), offset_of!(ExternalComputeQueueDeviceCreateInfoNV, s_type), offset_of!(ExternalComputeQueueDeviceCreateInfoNV, p_next), offset_of!(ExternalComputeQueueDeviceCreateInfoNV, reserved_external_queues));
    println!("ExternalComputeQueueCreateInfoNV {} {} {} {} {}", size_of::<ExternalComputeQueueCreateInfoNV>(), align_of::<ExternalComputeQueueCreateInfoNV>(), offset_of!(ExternalComputeQueueCreateInfoNV, s_type), offset_of!(ExternalComputeQueueCreateInfoNV, p_next), offset_of!(ExternalComputeQueueCreateInfoNV, preferred_queue));
    println!("ExternalComputeQueueDataParamsNV {} {} {} {} {}", size_of::<ExternalComputeQueueDataParamsNV>(), align_of::<ExternalComputeQueueDataParamsNV>(), offset_of!(ExternalComputeQueueDataParamsNV, s_type), offset_of!(ExternalComputeQueueDataParamsNV, p_next), offset_of!(ExternalComputeQueueDataParamsNV, device_index));
    println!("PhysicalDeviceExternalComputeQueuePropertiesNV {} {} {} {} {} {}", size_of::<PhysicalDeviceExternalComputeQueuePropertiesNV>(), align_of::<PhysicalDeviceExternalComputeQueuePropertiesNV>(), offset_of!(PhysicalDeviceExternalComputeQueuePropertiesNV, s_type), offset_of!(PhysicalDeviceExternalComputeQueuePropertiesNV, p_next), offset_of!(PhysicalDeviceExternalComputeQueuePropertiesNV, external_data_size), offset_of!(PhysicalDeviceExternalComputeQueuePropertiesNV, max_external_queues));
    println!("PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>(), align_of::<PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>(), offset_of!(PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, shader_uniform_buffer_unsized_array));
    println!("PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(), align_of::<PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(), offset_of!(PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE, s_type), offset_of!(PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE, p_next), offset_of!(PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE, shader_mixed_float_dot_product_float16_acc_float32), offset_of!(PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE, shader_mixed_float_dot_product_float16_acc_float16), offset_of!(PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE, shader_mixed_float_dot_product_b_float16_acc), offset_of!(PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE, shader_mixed_float_dot_product_float8_acc_float32));
    println!("PhysicalDeviceFormatPackFeaturesARM {} {} {} {} {}", size_of::<PhysicalDeviceFormatPackFeaturesARM>(), align_of::<PhysicalDeviceFormatPackFeaturesARM>(), offset_of!(PhysicalDeviceFormatPackFeaturesARM, s_type), offset_of!(PhysicalDeviceFormatPackFeaturesARM, p_next), offset_of!(PhysicalDeviceFormatPackFeaturesARM, format_pack));
    println!("TensorDescriptionARM {} {} {} {} {} {} {} {} {} {}", size_of::<TensorDescriptionARM>(), align_of::<TensorDescriptionARM>(), offset_of!(TensorDescriptionARM, s_type), offset_of!(TensorDescriptionARM, p_next), offset_of!(TensorDescriptionARM, tiling), offset_of!(TensorDescriptionARM, format), offset_of!(TensorDescriptionARM, dimension_count), offset_of!(TensorDescriptionARM, p_dimensions), offset_of!(TensorDescriptionARM, p_strides), offset_of!(TensorDescriptionARM, usage));
    println!("TensorCreateInfoARM {} {} {} {} {} {} {} {} {}", size_of::<TensorCreateInfoARM>(), align_of::<TensorCreateInfoARM>(), offset_of!(TensorCreateInfoARM, s_type), offset_of!(TensorCreateInfoARM, p_next), offset_of!(TensorCreateInfoARM, flags), offset_of!(TensorCreateInfoARM, p_description), offset_of!(TensorCreateInfoARM, sharing_mode), offset_of!(TensorCreateInfoARM, queue_family_index_count), offset_of!(TensorCreateInfoARM, p_queue_family_indices));
    println!("TensorViewCreateInfoARM {} {} {} {} {} {} {}", size_of::<TensorViewCreateInfoARM>(), align_of::<TensorViewCreateInfoARM>(), offset_of!(TensorViewCreateInfoARM, s_type), offset_of!(TensorViewCreateInfoARM, p_next), offset_of!(TensorViewCreateInfoARM, flags), offset_of!(TensorViewCreateInfoARM, tensor), offset_of!(TensorViewCreateInfoARM, format));
    println!("TensorMemoryRequirementsInfoARM {} {} {} {} {}", size_of::<TensorMemoryRequirementsInfoARM>(), align_of::<TensorMemoryRequirementsInfoARM>(), offset_of!(TensorMemoryRequirementsInfoARM, s_type), offset_of!(TensorMemoryRequirementsInfoARM, p_next), offset_of!(TensorMemoryRequirementsInfoARM, tensor));
    println!("BindTensorMemoryInfoARM {} {} {} {} {} {} {}", size_of::<BindTensorMemoryInfoARM>(), align_of::<BindTensorMemoryInfoARM>(), offset_of!(BindTensorMemoryInfoARM, s_type), offset_of!(BindTensorMemoryInfoARM, p_next), offset_of!(BindTensorMemoryInfoARM, tensor), offset_of!(BindTensorMemoryInfoARM, memory), offset_of!(BindTensorMemoryInfoARM, memory_offset));
    println!("WriteDescriptorSetTensorARM {} {} {} {} {} {}", size_of::<WriteDescriptorSetTensorARM>(), align_of::<WriteDescriptorSetTensorARM>(), offset_of!(WriteDescriptorSetTensorARM, s_type), offset_of!(WriteDescriptorSetTensorARM, p_next), offset_of!(WriteDescriptorSetTensorARM, tensor_view_count), offset_of!(WriteDescriptorSetTensorARM, p_tensor_views));
    println!("TensorFormatPropertiesARM {} {} {} {} {} {}", size_of::<TensorFormatPropertiesARM>(), align_of::<TensorFormatPropertiesARM>(), offset_of!(TensorFormatPropertiesARM, s_type), offset_of!(TensorFormatPropertiesARM, p_next), offset_of!(TensorFormatPropertiesARM, optimal_tiling_tensor_features), offset_of!(TensorFormatPropertiesARM, linear_tiling_tensor_features));
    println!("PhysicalDeviceTensorPropertiesARM {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceTensorPropertiesARM>(), align_of::<PhysicalDeviceTensorPropertiesARM>(), offset_of!(PhysicalDeviceTensorPropertiesARM, s_type), offset_of!(PhysicalDeviceTensorPropertiesARM, p_next), offset_of!(PhysicalDeviceTensorPropertiesARM, max_tensor_dimension_count), offset_of!(PhysicalDeviceTensorPropertiesARM, max_tensor_elements), offset_of!(PhysicalDeviceTensorPropertiesARM, max_per_dimension_tensor_elements), offset_of!(PhysicalDeviceTensorPropertiesARM, max_tensor_stride), offset_of!(PhysicalDeviceTensorPropertiesARM, max_tensor_size), offset_of!(PhysicalDeviceTensorPropertiesARM, max_tensor_shader_access_array_length), offset_of!(PhysicalDeviceTensorPropertiesARM, max_tensor_shader_access_size), offset_of!(PhysicalDeviceTensorPropertiesARM, max_descriptor_set_storage_tensors), offset_of!(PhysicalDeviceTensorPropertiesARM, max_per_stage_descriptor_set_storage_tensors), offset_of!(PhysicalDeviceTensorPropertiesARM, max_descriptor_set_update_after_bind_storage_tensors), offset_of!(PhysicalDeviceTensorPropertiesARM, max_per_stage_descriptor_update_after_bind_storage_tensors), offset_of!(PhysicalDeviceTensorPropertiesARM, shader_storage_tensor_array_non_uniform_indexing_native), offset_of!(PhysicalDeviceTensorPropertiesARM, shader_tensor_supported_stages));
    println!("TensorMemoryBarrierARM {} {} {} {} {} {} {} {} {} {} {}", size_of::<TensorMemoryBarrierARM>(), align_of::<TensorMemoryBarrierARM>(), offset_of!(TensorMemoryBarrierARM, s_type), offset_of!(TensorMemoryBarrierARM, p_next), offset_of!(TensorMemoryBarrierARM, src_stage_mask), offset_of!(TensorMemoryBarrierARM, src_access_mask), offset_of!(TensorMemoryBarrierARM, dst_stage_mask), offset_of!(TensorMemoryBarrierARM, dst_access_mask), offset_of!(TensorMemoryBarrierARM, src_queue_family_index), offset_of!(TensorMemoryBarrierARM, dst_queue_family_index), offset_of!(TensorMemoryBarrierARM, tensor));
    println!("TensorDependencyInfoARM {} {} {} {} {} {}", size_of::<TensorDependencyInfoARM>(), align_of::<TensorDependencyInfoARM>(), offset_of!(TensorDependencyInfoARM, s_type), offset_of!(TensorDependencyInfoARM, p_next), offset_of!(TensorDependencyInfoARM, tensor_memory_barrier_count), offset_of!(TensorDependencyInfoARM, p_tensor_memory_barriers));
    println!("PhysicalDeviceTensorFeaturesARM {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceTensorFeaturesARM>(), align_of::<PhysicalDeviceTensorFeaturesARM>(), offset_of!(PhysicalDeviceTensorFeaturesARM, s_type), offset_of!(PhysicalDeviceTensorFeaturesARM, p_next), offset_of!(PhysicalDeviceTensorFeaturesARM, tensor_non_packed), offset_of!(PhysicalDeviceTensorFeaturesARM, shader_tensor_access), offset_of!(PhysicalDeviceTensorFeaturesARM, shader_storage_tensor_array_dynamic_indexing), offset_of!(PhysicalDeviceTensorFeaturesARM, shader_storage_tensor_array_non_uniform_indexing), offset_of!(PhysicalDeviceTensorFeaturesARM, descriptor_binding_storage_tensor_update_after_bind), offset_of!(PhysicalDeviceTensorFeaturesARM, tensors));
    println!("DeviceTensorMemoryRequirementsARM {} {} {} {} {}", size_of::<DeviceTensorMemoryRequirementsARM>(), align_of::<DeviceTensorMemoryRequirementsARM>(), offset_of!(DeviceTensorMemoryRequirementsARM, s_type), offset_of!(DeviceTensorMemoryRequirementsARM, p_next), offset_of!(DeviceTensorMemoryRequirementsARM, p_create_info));
    println!("CopyTensorInfoARM {} {} {} {} {} {} {} {}", size_of::<CopyTensorInfoARM>(), align_of::<CopyTensorInfoARM>(), offset_of!(CopyTensorInfoARM, s_type), offset_of!(CopyTensorInfoARM, p_next), offset_of!(CopyTensorInfoARM, src_tensor), offset_of!(CopyTensorInfoARM, dst_tensor), offset_of!(CopyTensorInfoARM, region_count), offset_of!(CopyTensorInfoARM, p_regions));
    println!("TensorCopyARM {} {} {} {} {} {} {} {}", size_of::<TensorCopyARM>(), align_of::<TensorCopyARM>(), offset_of!(TensorCopyARM, s_type), offset_of!(TensorCopyARM, p_next), offset_of!(TensorCopyARM, dimension_count), offset_of!(TensorCopyARM, p_src_offset), offset_of!(TensorCopyARM, p_dst_offset), offset_of!(TensorCopyARM, p_extent));
    println!("MemoryDedicatedAllocateInfoTensorARM {} {} {} {} {}", size_of::<MemoryDedicatedAllocateInfoTensorARM>(), align_of::<MemoryDedicatedAllocateInfoTensorARM>(), offset_of!(MemoryDedicatedAllocateInfoTensorARM, s_type), offset_of!(MemoryDedicatedAllocateInfoTensorARM, p_next), offset_of!(MemoryDedicatedAllocateInfoTensorARM, tensor));
    println!("PhysicalDeviceDescriptorBufferTensorPropertiesARM {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorBufferTensorPropertiesARM>(), align_of::<PhysicalDeviceDescriptorBufferTensorPropertiesARM>(), offset_of!(PhysicalDeviceDescriptorBufferTensorPropertiesARM, s_type), offset_of!(PhysicalDeviceDescriptorBufferTensorPropertiesARM, p_next), offset_of!(PhysicalDeviceDescriptorBufferTensorPropertiesARM, tensor_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferTensorPropertiesARM, tensor_view_capture_replay_descriptor_data_size), offset_of!(PhysicalDeviceDescriptorBufferTensorPropertiesARM, tensor_descriptor_size));
    println!("PhysicalDeviceDescriptorBufferTensorFeaturesARM {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorBufferTensorFeaturesARM>(), align_of::<PhysicalDeviceDescriptorBufferTensorFeaturesARM>(), offset_of!(PhysicalDeviceDescriptorBufferTensorFeaturesARM, s_type), offset_of!(PhysicalDeviceDescriptorBufferTensorFeaturesARM, p_next), offset_of!(PhysicalDeviceDescriptorBufferTensorFeaturesARM, descriptor_buffer_tensor_descriptors));
    println!("TensorCaptureDescriptorDataInfoARM {} {} {} {} {}", size_of::<TensorCaptureDescriptorDataInfoARM>(), align_of::<TensorCaptureDescriptorDataInfoARM>(), offset_of!(TensorCaptureDescriptorDataInfoARM, s_type), offset_of!(TensorCaptureDescriptorDataInfoARM, p_next), offset_of!(TensorCaptureDescriptorDataInfoARM, tensor));
    println!("TensorViewCaptureDescriptorDataInfoARM {} {} {} {} {}", size_of::<TensorViewCaptureDescriptorDataInfoARM>(), align_of::<TensorViewCaptureDescriptorDataInfoARM>(), offset_of!(TensorViewCaptureDescriptorDataInfoARM, s_type), offset_of!(TensorViewCaptureDescriptorDataInfoARM, p_next), offset_of!(TensorViewCaptureDescriptorDataInfoARM, tensor_view));
    println!("DescriptorGetTensorInfoARM {} {} {} {} {}", size_of::<DescriptorGetTensorInfoARM>(), align_of::<DescriptorGetTensorInfoARM>(), offset_of!(DescriptorGetTensorInfoARM, s_type), offset_of!(DescriptorGetTensorInfoARM, p_next), offset_of!(DescriptorGetTensorInfoARM, tensor_view));
    println!("FrameBoundaryTensorsARM {} {} {} {} {} {}", size_of::<FrameBoundaryTensorsARM>(), align_of::<FrameBoundaryTensorsARM>(), offset_of!(FrameBoundaryTensorsARM, s_type), offset_of!(FrameBoundaryTensorsARM, p_next), offset_of!(FrameBoundaryTensorsARM, tensor_count), offset_of!(FrameBoundaryTensorsARM, p_tensors));
    println!("PhysicalDeviceExternalTensorInfoARM {} {} {} {} {} {} {}", size_of::<PhysicalDeviceExternalTensorInfoARM>(), align_of::<PhysicalDeviceExternalTensorInfoARM>(), offset_of!(PhysicalDeviceExternalTensorInfoARM, s_type), offset_of!(PhysicalDeviceExternalTensorInfoARM, p_next), offset_of!(PhysicalDeviceExternalTensorInfoARM, flags), offset_of!(PhysicalDeviceExternalTensorInfoARM, p_description), offset_of!(PhysicalDeviceExternalTensorInfoARM, handle_type));
    println!("ExternalTensorPropertiesARM {} {} {} {} {}", size_of::<ExternalTensorPropertiesARM>(), align_of::<ExternalTensorPropertiesARM>(), offset_of!(ExternalTensorPropertiesARM, s_type), offset_of!(ExternalTensorPropertiesARM, p_next), offset_of!(ExternalTensorPropertiesARM, external_memory_properties));
    println!("ExternalMemoryTensorCreateInfoARM {} {} {} {} {}", size_of::<ExternalMemoryTensorCreateInfoARM>(), align_of::<ExternalMemoryTensorCreateInfoARM>(), offset_of!(ExternalMemoryTensorCreateInfoARM, s_type), offset_of!(ExternalMemoryTensorCreateInfoARM, p_next), offset_of!(ExternalMemoryTensorCreateInfoARM, handle_types));
    println!("PhysicalDeviceShaderFloat8FeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderFloat8FeaturesEXT>(), align_of::<PhysicalDeviceShaderFloat8FeaturesEXT>(), offset_of!(PhysicalDeviceShaderFloat8FeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderFloat8FeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderFloat8FeaturesEXT, shader_float8), offset_of!(PhysicalDeviceShaderFloat8FeaturesEXT, shader_float8_cooperative_matrix));
    println!("PhysicalDeviceDataGraphFeaturesARM {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDataGraphFeaturesARM>(), align_of::<PhysicalDeviceDataGraphFeaturesARM>(), offset_of!(PhysicalDeviceDataGraphFeaturesARM, s_type), offset_of!(PhysicalDeviceDataGraphFeaturesARM, p_next), offset_of!(PhysicalDeviceDataGraphFeaturesARM, data_graph), offset_of!(PhysicalDeviceDataGraphFeaturesARM, data_graph_update_after_bind), offset_of!(PhysicalDeviceDataGraphFeaturesARM, data_graph_specialization_constants), offset_of!(PhysicalDeviceDataGraphFeaturesARM, data_graph_descriptor_buffer), offset_of!(PhysicalDeviceDataGraphFeaturesARM, data_graph_shader_module));
    println!("DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {} {} {} {} {} {} {}", size_of::<DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM>(), align_of::<DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM>(), offset_of!(DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, s_type), offset_of!(DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, p_next), offset_of!(DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, dimension), offset_of!(DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, zero_count), offset_of!(DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, group_size));
    println!("DataGraphPipelineConstantARM {} {} {} {} {} {}", size_of::<DataGraphPipelineConstantARM>(), align_of::<DataGraphPipelineConstantARM>(), offset_of!(DataGraphPipelineConstantARM, s_type), offset_of!(DataGraphPipelineConstantARM, p_next), offset_of!(DataGraphPipelineConstantARM, id), offset_of!(DataGraphPipelineConstantARM, p_constant_data));
    println!("DataGraphPipelineResourceInfoARM {} {} {} {} {} {} {}", size_of::<DataGraphPipelineResourceInfoARM>(), align_of::<DataGraphPipelineResourceInfoARM>(), offset_of!(DataGraphPipelineResourceInfoARM, s_type), offset_of!(DataGraphPipelineResourceInfoARM, p_next), offset_of!(DataGraphPipelineResourceInfoARM, descriptor_set), offset_of!(DataGraphPipelineResourceInfoARM, binding), offset_of!(DataGraphPipelineResourceInfoARM, array_element));
    println!("DataGraphPipelineCompilerControlCreateInfoARM {} {} {} {} {}", size_of::<DataGraphPipelineCompilerControlCreateInfoARM>(), align_of::<DataGraphPipelineCompilerControlCreateInfoARM>(), offset_of!(DataGraphPipelineCompilerControlCreateInfoARM, s_type), offset_of!(DataGraphPipelineCompilerControlCreateInfoARM, p_next), offset_of!(DataGraphPipelineCompilerControlCreateInfoARM, p_vendor_options));
    println!("DataGraphPipelineCreateInfoARM {} {} {} {} {} {} {} {}", size_of::<DataGraphPipelineCreateInfoARM>(), align_of::<DataGraphPipelineCreateInfoARM>(), offset_of!(DataGraphPipelineCreateInfoARM, s_type), offset_of!(DataGraphPipelineCreateInfoARM, p_next), offset_of!(DataGraphPipelineCreateInfoARM, flags), offset_of!(DataGraphPipelineCreateInfoARM, layout), offset_of!(DataGraphPipelineCreateInfoARM, resource_info_count), offset_of!(DataGraphPipelineCreateInfoARM, p_resource_infos));
    println!("DataGraphPipelineShaderModuleCreateInfoARM {} {} {} {} {} {} {} {} {}", size_of::<DataGraphPipelineShaderModuleCreateInfoARM>(), align_of::<DataGraphPipelineShaderModuleCreateInfoARM>(), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, s_type), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, p_next), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, module), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, p_name), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, p_specialization_info), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, constant_count), offset_of!(DataGraphPipelineShaderModuleCreateInfoARM, p_constants));
    println!("DataGraphPipelineSessionCreateInfoARM {} {} {} {} {} {}", size_of::<DataGraphPipelineSessionCreateInfoARM>(), align_of::<DataGraphPipelineSessionCreateInfoARM>(), offset_of!(DataGraphPipelineSessionCreateInfoARM, s_type), offset_of!(DataGraphPipelineSessionCreateInfoARM, p_next), offset_of!(DataGraphPipelineSessionCreateInfoARM, flags), offset_of!(DataGraphPipelineSessionCreateInfoARM, data_graph_pipeline));
    println!("DataGraphPipelineSessionBindPointRequirementsInfoARM {} {} {} {} {}", size_of::<DataGraphPipelineSessionBindPointRequirementsInfoARM>(), align_of::<DataGraphPipelineSessionBindPointRequirementsInfoARM>(), offset_of!(DataGraphPipelineSessionBindPointRequirementsInfoARM, s_type), offset_of!(DataGraphPipelineSessionBindPointRequirementsInfoARM, p_next), offset_of!(DataGraphPipelineSessionBindPointRequirementsInfoARM, session));
    println!("DataGraphPipelineSessionBindPointRequirementARM {} {} {} {} {} {} {}", size_of::<DataGraphPipelineSessionBindPointRequirementARM>(), align_of::<DataGraphPipelineSessionBindPointRequirementARM>(), offset_of!(DataGraphPipelineSessionBindPointRequirementARM, s_type), offset_of!(DataGraphPipelineSessionBindPointRequirementARM, p_next), offset_of!(DataGraphPipelineSessionBindPointRequirementARM, bind_point), offset_of!(DataGraphPipelineSessionBindPointRequirementARM, bind_point_type), offset_of!(DataGraphPipelineSessionBindPointRequirementARM, num_objects));
    println!("DataGraphPipelineSessionMemoryRequirementsInfoARM {} {} {} {} {} {} {}", size_of::<DataGraphPipelineSessionMemoryRequirementsInfoARM>(), align_of::<DataGraphPipelineSessionMemoryRequirementsInfoARM>(), offset_of!(DataGraphPipelineSessionMemoryRequirementsInfoARM, s_type), offset_of!(DataGraphPipelineSessionMemoryRequirementsInfoARM, p_next), offset_of!(DataGraphPipelineSessionMemoryRequirementsInfoARM, session), offset_of!(DataGraphPipelineSessionMemoryRequirementsInfoARM, bind_point), offset_of!(DataGraphPipelineSessionMemoryRequirementsInfoARM, object_index));
    println!("BindDataGraphPipelineSessionMemoryInfoARM {} {} {} {} {} {} {} {} {}", size_of::<BindDataGraphPipelineSessionMemoryInfoARM>(), align_of::<BindDataGraphPipelineSessionMemoryInfoARM>(), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, s_type), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, p_next), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, session), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, bind_point), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, object_index), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, memory), offset_of!(BindDataGraphPipelineSessionMemoryInfoARM, memory_offset));
    println!("DataGraphPipelineInfoARM {} {} {} {} {}", size_of::<DataGraphPipelineInfoARM>(), align_of::<DataGraphPipelineInfoARM>(), offset_of!(DataGraphPipelineInfoARM, s_type), offset_of!(DataGraphPipelineInfoARM, p_next), offset_of!(DataGraphPipelineInfoARM, data_graph_pipeline));
    println!("DataGraphPipelinePropertyQueryResultARM {} {} {} {} {} {} {} {}", size_of::<DataGraphPipelinePropertyQueryResultARM>(), align_of::<DataGraphPipelinePropertyQueryResultARM>(), offset_of!(DataGraphPipelinePropertyQueryResultARM, s_type), offset_of!(DataGraphPipelinePropertyQueryResultARM, p_next), offset_of!(DataGraphPipelinePropertyQueryResultARM, property), offset_of!(DataGraphPipelinePropertyQueryResultARM, is_text), offset_of!(DataGraphPipelinePropertyQueryResultARM, data_size), offset_of!(DataGraphPipelinePropertyQueryResultARM, p_data));
    println!("DataGraphPipelineIdentifierCreateInfoARM {} {} {} {} {} {}", size_of::<DataGraphPipelineIdentifierCreateInfoARM>(), align_of::<DataGraphPipelineIdentifierCreateInfoARM>(), offset_of!(DataGraphPipelineIdentifierCreateInfoARM, s_type), offset_of!(DataGraphPipelineIdentifierCreateInfoARM, p_next), offset_of!(DataGraphPipelineIdentifierCreateInfoARM, identifier_size), offset_of!(DataGraphPipelineIdentifierCreateInfoARM, p_identifier));
    println!("DataGraphPipelineDispatchInfoARM {} {} {} {} {}", size_of::<DataGraphPipelineDispatchInfoARM>(), align_of::<DataGraphPipelineDispatchInfoARM>(), offset_of!(DataGraphPipelineDispatchInfoARM, s_type), offset_of!(DataGraphPipelineDispatchInfoARM, p_next), offset_of!(DataGraphPipelineDispatchInfoARM, flags));
    println!("PhysicalDeviceDataGraphProcessingEngineARM {} {} {}", size_of::<PhysicalDeviceDataGraphProcessingEngineARM>(), align_of::<PhysicalDeviceDataGraphProcessingEngineARM>(), offset_of!(PhysicalDeviceDataGraphProcessingEngineARM, is_foreign));
    println!("PhysicalDeviceDataGraphOperationSupportARM {} {} {} {} {}", size_of::<PhysicalDeviceDataGraphOperationSupportARM>(), align_of::<PhysicalDeviceDataGraphOperationSupportARM>(), offset_of!(PhysicalDeviceDataGraphOperationSupportARM, operation_type), offset_of!(PhysicalDeviceDataGraphOperationSupportARM, name), offset_of!(PhysicalDeviceDataGraphOperationSupportARM, version));
    println!("QueueFamilyDataGraphPropertiesARM {} {} {} {} {} {}", size_of::<QueueFamilyDataGraphPropertiesARM>(), align_of::<QueueFamilyDataGraphPropertiesARM>(), offset_of!(QueueFamilyDataGraphPropertiesARM, s_type), offset_of!(QueueFamilyDataGraphPropertiesARM, p_next), offset_of!(QueueFamilyDataGraphPropertiesARM, engine), offset_of!(QueueFamilyDataGraphPropertiesARM, operation));
    println!("PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {} {} {} {} {} {}", size_of::<PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM>(), align_of::<PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM>(), offset_of!(PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, s_type), offset_of!(PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, p_next), offset_of!(PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, queue_family_index), offset_of!(PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, engine_type));
    println!("QueueFamilyDataGraphProcessingEnginePropertiesARM {} {} {} {} {} {}", size_of::<QueueFamilyDataGraphProcessingEnginePropertiesARM>(), align_of::<QueueFamilyDataGraphProcessingEnginePropertiesARM>(), offset_of!(QueueFamilyDataGraphProcessingEnginePropertiesARM, s_type), offset_of!(QueueFamilyDataGraphProcessingEnginePropertiesARM, p_next), offset_of!(QueueFamilyDataGraphProcessingEnginePropertiesARM, foreign_semaphore_handle_types), offset_of!(QueueFamilyDataGraphProcessingEnginePropertiesARM, foreign_memory_handle_types));
    println!("DataGraphProcessingEngineCreateInfoARM {} {} {} {} {} {}", size_of::<DataGraphProcessingEngineCreateInfoARM>(), align_of::<DataGraphProcessingEngineCreateInfoARM>(), offset_of!(DataGraphProcessingEngineCreateInfoARM, s_type), offset_of!(DataGraphProcessingEngineCreateInfoARM, p_next), offset_of!(DataGraphProcessingEngineCreateInfoARM, processing_engine_count), offset_of!(DataGraphProcessingEngineCreateInfoARM, p_processing_engines));
    println!("PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {} {} {} {} {}", size_of::<PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>(), align_of::<PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>(), offset_of!(PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, s_type), offset_of!(PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, p_next), offset_of!(PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, pipeline_cache_incremental_mode));
    println!("DataGraphPipelineBuiltinModelCreateInfoQCOM {} {} {} {} {}", size_of::<DataGraphPipelineBuiltinModelCreateInfoQCOM>(), align_of::<DataGraphPipelineBuiltinModelCreateInfoQCOM>(), offset_of!(DataGraphPipelineBuiltinModelCreateInfoQCOM, s_type), offset_of!(DataGraphPipelineBuiltinModelCreateInfoQCOM, p_next), offset_of!(DataGraphPipelineBuiltinModelCreateInfoQCOM, p_operation));
    println!("PhysicalDeviceDataGraphModelFeaturesQCOM {} {} {} {} {}", size_of::<PhysicalDeviceDataGraphModelFeaturesQCOM>(), align_of::<PhysicalDeviceDataGraphModelFeaturesQCOM>(), offset_of!(PhysicalDeviceDataGraphModelFeaturesQCOM, s_type), offset_of!(PhysicalDeviceDataGraphModelFeaturesQCOM, p_next), offset_of!(PhysicalDeviceDataGraphModelFeaturesQCOM, data_graph_model));
    println!("PhysicalDeviceShaderUntypedPointersFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderUntypedPointersFeaturesKHR>(), align_of::<PhysicalDeviceShaderUntypedPointersFeaturesKHR>(), offset_of!(PhysicalDeviceShaderUntypedPointersFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderUntypedPointersFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderUntypedPointersFeaturesKHR, shader_untyped_pointers));
    println!("PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {} {} {} {} {}", size_of::<PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>(), align_of::<PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>(), offset_of!(PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, s_type), offset_of!(PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, p_next), offset_of!(PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, video_encode_rgb_conversion));
    println!("VideoEncodeRgbConversionCapabilitiesVALVE {} {} {} {} {} {} {} {}", size_of::<VideoEncodeRgbConversionCapabilitiesVALVE>(), align_of::<VideoEncodeRgbConversionCapabilitiesVALVE>(), offset_of!(VideoEncodeRgbConversionCapabilitiesVALVE, s_type), offset_of!(VideoEncodeRgbConversionCapabilitiesVALVE, p_next), offset_of!(VideoEncodeRgbConversionCapabilitiesVALVE, rgb_models), offset_of!(VideoEncodeRgbConversionCapabilitiesVALVE, rgb_ranges), offset_of!(VideoEncodeRgbConversionCapabilitiesVALVE, x_chroma_offsets), offset_of!(VideoEncodeRgbConversionCapabilitiesVALVE, y_chroma_offsets));
    println!("VideoEncodeProfileRgbConversionInfoVALVE {} {} {} {} {}", size_of::<VideoEncodeProfileRgbConversionInfoVALVE>(), align_of::<VideoEncodeProfileRgbConversionInfoVALVE>(), offset_of!(VideoEncodeProfileRgbConversionInfoVALVE, s_type), offset_of!(VideoEncodeProfileRgbConversionInfoVALVE, p_next), offset_of!(VideoEncodeProfileRgbConversionInfoVALVE, perform_encode_rgb_conversion));
    println!("VideoEncodeSessionRgbConversionCreateInfoVALVE {} {} {} {} {} {} {} {}", size_of::<VideoEncodeSessionRgbConversionCreateInfoVALVE>(), align_of::<VideoEncodeSessionRgbConversionCreateInfoVALVE>(), offset_of!(VideoEncodeSessionRgbConversionCreateInfoVALVE, s_type), offset_of!(VideoEncodeSessionRgbConversionCreateInfoVALVE, p_next), offset_of!(VideoEncodeSessionRgbConversionCreateInfoVALVE, rgb_model), offset_of!(VideoEncodeSessionRgbConversionCreateInfoVALVE, rgb_range), offset_of!(VideoEncodeSessionRgbConversionCreateInfoVALVE, x_chroma_offset), offset_of!(VideoEncodeSessionRgbConversionCreateInfoVALVE, y_chroma_offset));
    println!("PhysicalDeviceShader64BitIndexingFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShader64BitIndexingFeaturesEXT>(), align_of::<PhysicalDeviceShader64BitIndexingFeaturesEXT>(), offset_of!(PhysicalDeviceShader64BitIndexingFeaturesEXT, s_type), offset_of!(PhysicalDeviceShader64BitIndexingFeaturesEXT, p_next), offset_of!(PhysicalDeviceShader64BitIndexingFeaturesEXT, shader64_bit_indexing));
    println!("PhysicalDevicePerformanceCountersByRegionFeaturesARM {} {} {} {} {}", size_of::<PhysicalDevicePerformanceCountersByRegionFeaturesARM>(), align_of::<PhysicalDevicePerformanceCountersByRegionFeaturesARM>(), offset_of!(PhysicalDevicePerformanceCountersByRegionFeaturesARM, s_type), offset_of!(PhysicalDevicePerformanceCountersByRegionFeaturesARM, p_next), offset_of!(PhysicalDevicePerformanceCountersByRegionFeaturesARM, performance_counters_by_region));
    println!("PhysicalDevicePerformanceCountersByRegionPropertiesARM {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDevicePerformanceCountersByRegionPropertiesARM>(), align_of::<PhysicalDevicePerformanceCountersByRegionPropertiesARM>(), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, s_type), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, p_next), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, max_per_region_performance_counters), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, performance_counter_region_size), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, row_stride_alignment), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, region_alignment), offset_of!(PhysicalDevicePerformanceCountersByRegionPropertiesARM, identity_transform_order));
    println!("PerformanceCounterARM {} {} {} {} {}", size_of::<PerformanceCounterARM>(), align_of::<PerformanceCounterARM>(), offset_of!(PerformanceCounterARM, s_type), offset_of!(PerformanceCounterARM, p_next), offset_of!(PerformanceCounterARM, counter_id));
    println!("PerformanceCounterDescriptionARM {} {} {} {} {} {}", size_of::<PerformanceCounterDescriptionARM>(), align_of::<PerformanceCounterDescriptionARM>(), offset_of!(PerformanceCounterDescriptionARM, s_type), offset_of!(PerformanceCounterDescriptionARM, p_next), offset_of!(PerformanceCounterDescriptionARM, flags), offset_of!(PerformanceCounterDescriptionARM, name));
    println!("RenderPassPerformanceCountersByRegionBeginInfoARM {} {} {} {} {} {} {} {} {}", size_of::<RenderPassPerformanceCountersByRegionBeginInfoARM>(), align_of::<RenderPassPerformanceCountersByRegionBeginInfoARM>(), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, s_type), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, p_next), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, counter_address_count), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, p_counter_addresses), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, serialize_regions), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, counter_index_count), offset_of!(RenderPassPerformanceCountersByRegionBeginInfoARM, p_counter_indices));
    println!("ComputeOccupancyPriorityParametersNV {} {} {} {} {} {}", size_of::<ComputeOccupancyPriorityParametersNV>(), align_of::<ComputeOccupancyPriorityParametersNV>(), offset_of!(ComputeOccupancyPriorityParametersNV, s_type), offset_of!(ComputeOccupancyPriorityParametersNV, p_next), offset_of!(ComputeOccupancyPriorityParametersNV, occupancy_priority), offset_of!(ComputeOccupancyPriorityParametersNV, occupancy_throttling));
    println!("PhysicalDeviceComputeOccupancyPriorityFeaturesNV {} {} {} {} {}", size_of::<PhysicalDeviceComputeOccupancyPriorityFeaturesNV>(), align_of::<PhysicalDeviceComputeOccupancyPriorityFeaturesNV>(), offset_of!(PhysicalDeviceComputeOccupancyPriorityFeaturesNV, s_type), offset_of!(PhysicalDeviceComputeOccupancyPriorityFeaturesNV, p_next), offset_of!(PhysicalDeviceComputeOccupancyPriorityFeaturesNV, compute_occupancy_priority));
    println!("PhysicalDeviceShaderLongVectorFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderLongVectorFeaturesEXT>(), align_of::<PhysicalDeviceShaderLongVectorFeaturesEXT>(), offset_of!(PhysicalDeviceShaderLongVectorFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderLongVectorFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderLongVectorFeaturesEXT, long_vector));
    println!("PhysicalDeviceShaderLongVectorPropertiesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderLongVectorPropertiesEXT>(), align_of::<PhysicalDeviceShaderLongVectorPropertiesEXT>(), offset_of!(PhysicalDeviceShaderLongVectorPropertiesEXT, s_type), offset_of!(PhysicalDeviceShaderLongVectorPropertiesEXT, p_next), offset_of!(PhysicalDeviceShaderLongVectorPropertiesEXT, max_vector_components));
    println!("PhysicalDeviceTextureCompressionASTC3DFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceTextureCompressionASTC3DFeaturesEXT>(), align_of::<PhysicalDeviceTextureCompressionASTC3DFeaturesEXT>(), offset_of!(PhysicalDeviceTextureCompressionASTC3DFeaturesEXT, s_type), offset_of!(PhysicalDeviceTextureCompressionASTC3DFeaturesEXT, p_next), offset_of!(PhysicalDeviceTextureCompressionASTC3DFeaturesEXT, texture_compression_astc_3d));
    println!("PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {} {} {} {} {}", size_of::<PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>(), align_of::<PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>(), offset_of!(PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, s_type), offset_of!(PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, p_next), offset_of!(PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, shader_subgroup_partitioned));
    println!("HostAddressRangeEXT {} {} {} {}", size_of::<HostAddressRangeEXT>(), align_of::<HostAddressRangeEXT>(), offset_of!(HostAddressRangeEXT, address), offset_of!(HostAddressRangeEXT, size));
    println!("HostAddressRangeConstEXT {} {} {} {}", size_of::<HostAddressRangeConstEXT>(), align_of::<HostAddressRangeConstEXT>(), offset_of!(HostAddressRangeConstEXT, address), offset_of!(HostAddressRangeConstEXT, size));
    println!("TexelBufferDescriptorInfoEXT {} {} {} {} {} {}", size_of::<TexelBufferDescriptorInfoEXT>(), align_of::<TexelBufferDescriptorInfoEXT>(), offset_of!(TexelBufferDescriptorInfoEXT, s_type), offset_of!(TexelBufferDescriptorInfoEXT, p_next), offset_of!(TexelBufferDescriptorInfoEXT, format), offset_of!(TexelBufferDescriptorInfoEXT, address_range));
    println!("ImageDescriptorInfoEXT {} {} {} {} {} {}", size_of::<ImageDescriptorInfoEXT>(), align_of::<ImageDescriptorInfoEXT>(), offset_of!(ImageDescriptorInfoEXT, s_type), offset_of!(ImageDescriptorInfoEXT, p_next), offset_of!(ImageDescriptorInfoEXT, p_view), offset_of!(ImageDescriptorInfoEXT, layout));
    println!("ResourceDescriptorDataEXT {} {} {} {} {} {}", size_of::<ResourceDescriptorDataEXT>(), align_of::<ResourceDescriptorDataEXT>(), offset_of!(ResourceDescriptorDataEXT, p_image), offset_of!(ResourceDescriptorDataEXT, p_texel_buffer), offset_of!(ResourceDescriptorDataEXT, p_address_range), offset_of!(ResourceDescriptorDataEXT, p_tensor_arm));
    println!("ResourceDescriptorInfoEXT {} {} {} {} {}", size_of::<ResourceDescriptorInfoEXT>(), align_of::<ResourceDescriptorInfoEXT>(), offset_of!(ResourceDescriptorInfoEXT, s_type), offset_of!(ResourceDescriptorInfoEXT, p_next), offset_of!(ResourceDescriptorInfoEXT, data));
    println!("BindHeapInfoEXT {} {} {} {} {} {} {}", size_of::<BindHeapInfoEXT>(), align_of::<BindHeapInfoEXT>(), offset_of!(BindHeapInfoEXT, s_type), offset_of!(BindHeapInfoEXT, p_next), offset_of!(BindHeapInfoEXT, heap_range), offset_of!(BindHeapInfoEXT, reserved_range_offset), offset_of!(BindHeapInfoEXT, reserved_range_size));
    println!("PushDataInfoEXT {} {} {} {} {} {}", size_of::<PushDataInfoEXT>(), align_of::<PushDataInfoEXT>(), offset_of!(PushDataInfoEXT, s_type), offset_of!(PushDataInfoEXT, p_next), offset_of!(PushDataInfoEXT, offset), offset_of!(PushDataInfoEXT, data));
    println!("DescriptorMappingSourceConstantOffsetEXT {} {} {} {} {} {} {}", size_of::<DescriptorMappingSourceConstantOffsetEXT>(), align_of::<DescriptorMappingSourceConstantOffsetEXT>(), offset_of!(DescriptorMappingSourceConstantOffsetEXT, heap_offset), offset_of!(DescriptorMappingSourceConstantOffsetEXT, heap_array_stride), offset_of!(DescriptorMappingSourceConstantOffsetEXT, p_embedded_sampler), offset_of!(DescriptorMappingSourceConstantOffsetEXT, sampler_heap_offset), offset_of!(DescriptorMappingSourceConstantOffsetEXT, sampler_heap_array_stride));
    println!("DescriptorMappingSourcePushIndexEXT {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorMappingSourcePushIndexEXT>(), align_of::<DescriptorMappingSourcePushIndexEXT>(), offset_of!(DescriptorMappingSourcePushIndexEXT, heap_offset), offset_of!(DescriptorMappingSourcePushIndexEXT, push_offset), offset_of!(DescriptorMappingSourcePushIndexEXT, heap_index_stride), offset_of!(DescriptorMappingSourcePushIndexEXT, heap_array_stride), offset_of!(DescriptorMappingSourcePushIndexEXT, p_embedded_sampler), offset_of!(DescriptorMappingSourcePushIndexEXT, use_combined_image_sampler_index), offset_of!(DescriptorMappingSourcePushIndexEXT, sampler_heap_offset), offset_of!(DescriptorMappingSourcePushIndexEXT, sampler_push_offset), offset_of!(DescriptorMappingSourcePushIndexEXT, sampler_heap_index_stride), offset_of!(DescriptorMappingSourcePushIndexEXT, sampler_heap_array_stride));
    println!("DescriptorMappingSourceIndirectIndexEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorMappingSourceIndirectIndexEXT>(), align_of::<DescriptorMappingSourceIndirectIndexEXT>(), offset_of!(DescriptorMappingSourceIndirectIndexEXT, heap_offset), offset_of!(DescriptorMappingSourceIndirectIndexEXT, push_offset), offset_of!(DescriptorMappingSourceIndirectIndexEXT, address_offset), offset_of!(DescriptorMappingSourceIndirectIndexEXT, heap_index_stride), offset_of!(DescriptorMappingSourceIndirectIndexEXT, heap_array_stride), offset_of!(DescriptorMappingSourceIndirectIndexEXT, p_embedded_sampler), offset_of!(DescriptorMappingSourceIndirectIndexEXT, use_combined_image_sampler_index), offset_of!(DescriptorMappingSourceIndirectIndexEXT, sampler_heap_offset), offset_of!(DescriptorMappingSourceIndirectIndexEXT, sampler_push_offset), offset_of!(DescriptorMappingSourceIndirectIndexEXT, sampler_address_offset), offset_of!(DescriptorMappingSourceIndirectIndexEXT, sampler_heap_index_stride), offset_of!(DescriptorMappingSourceIndirectIndexEXT, sampler_heap_array_stride));
    println!("DescriptorMappingSourceIndirectIndexArrayEXT {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorMappingSourceIndirectIndexArrayEXT>(), align_of::<DescriptorMappingSourceIndirectIndexArrayEXT>(), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, heap_offset), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, push_offset), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, address_offset), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, heap_index_stride), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, p_embedded_sampler), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, use_combined_image_sampler_index), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, sampler_heap_offset), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, sampler_push_offset), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, sampler_address_offset), offset_of!(DescriptorMappingSourceIndirectIndexArrayEXT, sampler_heap_index_stride));
    println!("DescriptorMappingSourceHeapDataEXT {} {} {} {}", size_of::<DescriptorMappingSourceHeapDataEXT>(), align_of::<DescriptorMappingSourceHeapDataEXT>(), offset_of!(DescriptorMappingSourceHeapDataEXT, heap_offset), offset_of!(DescriptorMappingSourceHeapDataEXT, push_offset));
    println!("DescriptorMappingSourceShaderRecordIndexEXT {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorMappingSourceShaderRecordIndexEXT>(), align_of::<DescriptorMappingSourceShaderRecordIndexEXT>(), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, heap_offset), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, shader_record_offset), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, heap_index_stride), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, heap_array_stride), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, p_embedded_sampler), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, use_combined_image_sampler_index), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, sampler_heap_offset), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, sampler_shader_record_offset), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, sampler_heap_index_stride), offset_of!(DescriptorMappingSourceShaderRecordIndexEXT, sampler_heap_array_stride));
    println!("DescriptorMappingSourceIndirectAddressEXT {} {} {} {}", size_of::<DescriptorMappingSourceIndirectAddressEXT>(), align_of::<DescriptorMappingSourceIndirectAddressEXT>(), offset_of!(DescriptorMappingSourceIndirectAddressEXT, push_offset), offset_of!(DescriptorMappingSourceIndirectAddressEXT, address_offset));
    println!("DescriptorMappingSourceDataEXT {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorMappingSourceDataEXT>(), align_of::<DescriptorMappingSourceDataEXT>(), offset_of!(DescriptorMappingSourceDataEXT, constant_offset), offset_of!(DescriptorMappingSourceDataEXT, push_index), offset_of!(DescriptorMappingSourceDataEXT, indirect_index), offset_of!(DescriptorMappingSourceDataEXT, indirect_index_array), offset_of!(DescriptorMappingSourceDataEXT, heap_data), offset_of!(DescriptorMappingSourceDataEXT, push_data_offset), offset_of!(DescriptorMappingSourceDataEXT, push_address_offset), offset_of!(DescriptorMappingSourceDataEXT, indirect_address), offset_of!(DescriptorMappingSourceDataEXT, shader_record_index), offset_of!(DescriptorMappingSourceDataEXT, shader_record_data_offset), offset_of!(DescriptorMappingSourceDataEXT, shader_record_address_offset));
    println!("DescriptorSetAndBindingMappingEXT {} {} {} {} {} {} {} {} {} {}", size_of::<DescriptorSetAndBindingMappingEXT>(), align_of::<DescriptorSetAndBindingMappingEXT>(), offset_of!(DescriptorSetAndBindingMappingEXT, s_type), offset_of!(DescriptorSetAndBindingMappingEXT, p_next), offset_of!(DescriptorSetAndBindingMappingEXT, descriptor_set), offset_of!(DescriptorSetAndBindingMappingEXT, first_binding), offset_of!(DescriptorSetAndBindingMappingEXT, binding_count), offset_of!(DescriptorSetAndBindingMappingEXT, resource_mask), offset_of!(DescriptorSetAndBindingMappingEXT, source), offset_of!(DescriptorSetAndBindingMappingEXT, source_data));
    println!("ShaderDescriptorSetAndBindingMappingInfoEXT {} {} {} {} {} {}", size_of::<ShaderDescriptorSetAndBindingMappingInfoEXT>(), align_of::<ShaderDescriptorSetAndBindingMappingInfoEXT>(), offset_of!(ShaderDescriptorSetAndBindingMappingInfoEXT, s_type), offset_of!(ShaderDescriptorSetAndBindingMappingInfoEXT, p_next), offset_of!(ShaderDescriptorSetAndBindingMappingInfoEXT, mapping_count), offset_of!(ShaderDescriptorSetAndBindingMappingInfoEXT, p_mappings));
    println!("SamplerCustomBorderColorIndexCreateInfoEXT {} {} {} {} {}", size_of::<SamplerCustomBorderColorIndexCreateInfoEXT>(), align_of::<SamplerCustomBorderColorIndexCreateInfoEXT>(), offset_of!(SamplerCustomBorderColorIndexCreateInfoEXT, s_type), offset_of!(SamplerCustomBorderColorIndexCreateInfoEXT, p_next), offset_of!(SamplerCustomBorderColorIndexCreateInfoEXT, index));
    println!("OpaqueCaptureDataCreateInfoEXT {} {} {} {} {}", size_of::<OpaqueCaptureDataCreateInfoEXT>(), align_of::<OpaqueCaptureDataCreateInfoEXT>(), offset_of!(OpaqueCaptureDataCreateInfoEXT, s_type), offset_of!(OpaqueCaptureDataCreateInfoEXT, p_next), offset_of!(OpaqueCaptureDataCreateInfoEXT, p_data));
    println!("IndirectCommandsLayoutPushDataTokenNV {} {} {} {} {} {}", size_of::<IndirectCommandsLayoutPushDataTokenNV>(), align_of::<IndirectCommandsLayoutPushDataTokenNV>(), offset_of!(IndirectCommandsLayoutPushDataTokenNV, s_type), offset_of!(IndirectCommandsLayoutPushDataTokenNV, p_next), offset_of!(IndirectCommandsLayoutPushDataTokenNV, push_data_offset), offset_of!(IndirectCommandsLayoutPushDataTokenNV, push_data_size));
    println!("SubsampledImageFormatPropertiesEXT {} {} {} {} {}", size_of::<SubsampledImageFormatPropertiesEXT>(), align_of::<SubsampledImageFormatPropertiesEXT>(), offset_of!(SubsampledImageFormatPropertiesEXT, s_type), offset_of!(SubsampledImageFormatPropertiesEXT, p_next), offset_of!(SubsampledImageFormatPropertiesEXT, subsampled_image_descriptor_count));
    println!("PhysicalDeviceDescriptorHeapFeaturesEXT {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorHeapFeaturesEXT>(), align_of::<PhysicalDeviceDescriptorHeapFeaturesEXT>(), offset_of!(PhysicalDeviceDescriptorHeapFeaturesEXT, s_type), offset_of!(PhysicalDeviceDescriptorHeapFeaturesEXT, p_next), offset_of!(PhysicalDeviceDescriptorHeapFeaturesEXT, descriptor_heap), offset_of!(PhysicalDeviceDescriptorHeapFeaturesEXT, descriptor_heap_capture_replay));
    println!("PhysicalDeviceDescriptorHeapPropertiesEXT {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorHeapPropertiesEXT>(), align_of::<PhysicalDeviceDescriptorHeapPropertiesEXT>(), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, s_type), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, p_next), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, sampler_heap_alignment), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, resource_heap_alignment), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, max_sampler_heap_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, max_resource_heap_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, min_sampler_heap_reserved_range), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, min_sampler_heap_reserved_range_with_embedded), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, min_resource_heap_reserved_range), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, sampler_descriptor_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, image_descriptor_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, buffer_descriptor_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, sampler_descriptor_alignment), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, image_descriptor_alignment), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, buffer_descriptor_alignment), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, max_push_data_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, image_capture_replay_opaque_data_size), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, max_descriptor_heap_embedded_samplers), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, sampler_ycbcr_conversion_count), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, sparse_descriptor_heaps), offset_of!(PhysicalDeviceDescriptorHeapPropertiesEXT, protected_descriptor_heaps));
    println!("CommandBufferInheritanceDescriptorHeapInfoEXT {} {} {} {} {} {}", size_of::<CommandBufferInheritanceDescriptorHeapInfoEXT>(), align_of::<CommandBufferInheritanceDescriptorHeapInfoEXT>(), offset_of!(CommandBufferInheritanceDescriptorHeapInfoEXT, s_type), offset_of!(CommandBufferInheritanceDescriptorHeapInfoEXT, p_next), offset_of!(CommandBufferInheritanceDescriptorHeapInfoEXT, p_sampler_heap_bind_info), offset_of!(CommandBufferInheritanceDescriptorHeapInfoEXT, p_resource_heap_bind_info));
    println!("PhysicalDeviceDescriptorHeapTensorPropertiesARM {} {} {} {} {} {} {}", size_of::<PhysicalDeviceDescriptorHeapTensorPropertiesARM>(), align_of::<PhysicalDeviceDescriptorHeapTensorPropertiesARM>(), offset_of!(PhysicalDeviceDescriptorHeapTensorPropertiesARM, s_type), offset_of!(PhysicalDeviceDescriptorHeapTensorPropertiesARM, p_next), offset_of!(PhysicalDeviceDescriptorHeapTensorPropertiesARM, tensor_descriptor_size), offset_of!(PhysicalDeviceDescriptorHeapTensorPropertiesARM, tensor_descriptor_alignment), offset_of!(PhysicalDeviceDescriptorHeapTensorPropertiesARM, tensor_capture_replay_opaque_data_size));
    println!("PhysicalDeviceShaderInstrumentationFeaturesARM {} {} {} {} {}", size_of::<PhysicalDeviceShaderInstrumentationFeaturesARM>(), align_of::<PhysicalDeviceShaderInstrumentationFeaturesARM>(), offset_of!(PhysicalDeviceShaderInstrumentationFeaturesARM, s_type), offset_of!(PhysicalDeviceShaderInstrumentationFeaturesARM, p_next), offset_of!(PhysicalDeviceShaderInstrumentationFeaturesARM, shader_instrumentation));
    println!("PhysicalDeviceShaderInstrumentationPropertiesARM {} {} {} {} {} {}", size_of::<PhysicalDeviceShaderInstrumentationPropertiesARM>(), align_of::<PhysicalDeviceShaderInstrumentationPropertiesARM>(), offset_of!(PhysicalDeviceShaderInstrumentationPropertiesARM, s_type), offset_of!(PhysicalDeviceShaderInstrumentationPropertiesARM, p_next), offset_of!(PhysicalDeviceShaderInstrumentationPropertiesARM, num_metrics), offset_of!(PhysicalDeviceShaderInstrumentationPropertiesARM, per_basic_block_granularity));
    println!("ShaderInstrumentationCreateInfoARM {} {} {} {}", size_of::<ShaderInstrumentationCreateInfoARM>(), align_of::<ShaderInstrumentationCreateInfoARM>(), offset_of!(ShaderInstrumentationCreateInfoARM, s_type), offset_of!(ShaderInstrumentationCreateInfoARM, p_next));
    println!("ShaderInstrumentationMetricDescriptionARM {} {} {} {} {} {}", size_of::<ShaderInstrumentationMetricDescriptionARM>(), align_of::<ShaderInstrumentationMetricDescriptionARM>(), offset_of!(ShaderInstrumentationMetricDescriptionARM, s_type), offset_of!(ShaderInstrumentationMetricDescriptionARM, p_next), offset_of!(ShaderInstrumentationMetricDescriptionARM, name), offset_of!(ShaderInstrumentationMetricDescriptionARM, description));
    println!("ShaderInstrumentationMetricDataHeaderARM {} {} {} {} {} {}", size_of::<ShaderInstrumentationMetricDataHeaderARM>(), align_of::<ShaderInstrumentationMetricDataHeaderARM>(), offset_of!(ShaderInstrumentationMetricDataHeaderARM, result_index), offset_of!(ShaderInstrumentationMetricDataHeaderARM, result_sub_index), offset_of!(ShaderInstrumentationMetricDataHeaderARM, stages), offset_of!(ShaderInstrumentationMetricDataHeaderARM, basic_block_index));
    println!("DeviceAddressRangeKHR {} {} {} {}", size_of::<DeviceAddressRangeKHR>(), align_of::<DeviceAddressRangeKHR>(), offset_of!(DeviceAddressRangeKHR, address), offset_of!(DeviceAddressRangeKHR, size));
    println!("DeviceMemoryCopyKHR {} {} {} {} {} {} {} {}", size_of::<DeviceMemoryCopyKHR>(), align_of::<DeviceMemoryCopyKHR>(), offset_of!(DeviceMemoryCopyKHR, s_type), offset_of!(DeviceMemoryCopyKHR, p_next), offset_of!(DeviceMemoryCopyKHR, src_range), offset_of!(DeviceMemoryCopyKHR, src_flags), offset_of!(DeviceMemoryCopyKHR, dst_range), offset_of!(DeviceMemoryCopyKHR, dst_flags));
    println!("CopyDeviceMemoryInfoKHR {} {} {} {} {} {}", size_of::<CopyDeviceMemoryInfoKHR>(), align_of::<CopyDeviceMemoryInfoKHR>(), offset_of!(CopyDeviceMemoryInfoKHR, s_type), offset_of!(CopyDeviceMemoryInfoKHR, p_next), offset_of!(CopyDeviceMemoryInfoKHR, region_count), offset_of!(CopyDeviceMemoryInfoKHR, p_regions));
    println!("DeviceMemoryImageCopyKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<DeviceMemoryImageCopyKHR>(), align_of::<DeviceMemoryImageCopyKHR>(), offset_of!(DeviceMemoryImageCopyKHR, s_type), offset_of!(DeviceMemoryImageCopyKHR, p_next), offset_of!(DeviceMemoryImageCopyKHR, address_range), offset_of!(DeviceMemoryImageCopyKHR, address_flags), offset_of!(DeviceMemoryImageCopyKHR, address_row_length), offset_of!(DeviceMemoryImageCopyKHR, address_image_height), offset_of!(DeviceMemoryImageCopyKHR, image_subresource), offset_of!(DeviceMemoryImageCopyKHR, image_layout), offset_of!(DeviceMemoryImageCopyKHR, image_offset), offset_of!(DeviceMemoryImageCopyKHR, image_extent));
    println!("CopyDeviceMemoryImageInfoKHR {} {} {} {} {} {} {}", size_of::<CopyDeviceMemoryImageInfoKHR>(), align_of::<CopyDeviceMemoryImageInfoKHR>(), offset_of!(CopyDeviceMemoryImageInfoKHR, s_type), offset_of!(CopyDeviceMemoryImageInfoKHR, p_next), offset_of!(CopyDeviceMemoryImageInfoKHR, image), offset_of!(CopyDeviceMemoryImageInfoKHR, region_count), offset_of!(CopyDeviceMemoryImageInfoKHR, p_regions));
    println!("MemoryRangeBarriersInfoKHR {} {} {} {} {} {}", size_of::<MemoryRangeBarriersInfoKHR>(), align_of::<MemoryRangeBarriersInfoKHR>(), offset_of!(MemoryRangeBarriersInfoKHR, s_type), offset_of!(MemoryRangeBarriersInfoKHR, p_next), offset_of!(MemoryRangeBarriersInfoKHR, memory_range_barrier_count), offset_of!(MemoryRangeBarriersInfoKHR, p_memory_range_barriers));
    println!("MemoryRangeBarrierKHR {} {} {} {} {} {} {} {} {} {} {} {}", size_of::<MemoryRangeBarrierKHR>(), align_of::<MemoryRangeBarrierKHR>(), offset_of!(MemoryRangeBarrierKHR, s_type), offset_of!(MemoryRangeBarrierKHR, p_next), offset_of!(MemoryRangeBarrierKHR, src_stage_mask), offset_of!(MemoryRangeBarrierKHR, src_access_mask), offset_of!(MemoryRangeBarrierKHR, dst_stage_mask), offset_of!(MemoryRangeBarrierKHR, dst_access_mask), offset_of!(MemoryRangeBarrierKHR, src_queue_family_index), offset_of!(MemoryRangeBarrierKHR, dst_queue_family_index), offset_of!(MemoryRangeBarrierKHR, address_range), offset_of!(MemoryRangeBarrierKHR, address_flags));
    println!("PhysicalDeviceDeviceAddressCommandsFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceDeviceAddressCommandsFeaturesKHR>(), align_of::<PhysicalDeviceDeviceAddressCommandsFeaturesKHR>(), offset_of!(PhysicalDeviceDeviceAddressCommandsFeaturesKHR, s_type), offset_of!(PhysicalDeviceDeviceAddressCommandsFeaturesKHR, p_next), offset_of!(PhysicalDeviceDeviceAddressCommandsFeaturesKHR, device_address_commands));
    println!("ConditionalRenderingBeginInfo2EXT {} {} {} {} {} {} {}", size_of::<ConditionalRenderingBeginInfo2EXT>(), align_of::<ConditionalRenderingBeginInfo2EXT>(), offset_of!(ConditionalRenderingBeginInfo2EXT, s_type), offset_of!(ConditionalRenderingBeginInfo2EXT, p_next), offset_of!(ConditionalRenderingBeginInfo2EXT, address_range), offset_of!(ConditionalRenderingBeginInfo2EXT, address_flags), offset_of!(ConditionalRenderingBeginInfo2EXT, flags));
    println!("AccelerationStructureCreateInfo2KHR {} {} {} {} {} {} {}", size_of::<AccelerationStructureCreateInfo2KHR>(), align_of::<AccelerationStructureCreateInfo2KHR>(), offset_of!(AccelerationStructureCreateInfo2KHR, s_type), offset_of!(AccelerationStructureCreateInfo2KHR, p_next), offset_of!(AccelerationStructureCreateInfo2KHR, create_flags), offset_of!(AccelerationStructureCreateInfo2KHR, address_range), offset_of!(AccelerationStructureCreateInfo2KHR, address_flags));
    println!("BindIndexBuffer3InfoKHR {} {} {} {} {} {} {}", size_of::<BindIndexBuffer3InfoKHR>(), align_of::<BindIndexBuffer3InfoKHR>(), offset_of!(BindIndexBuffer3InfoKHR, s_type), offset_of!(BindIndexBuffer3InfoKHR, p_next), offset_of!(BindIndexBuffer3InfoKHR, address_range), offset_of!(BindIndexBuffer3InfoKHR, address_flags), offset_of!(BindIndexBuffer3InfoKHR, index_type));
    println!("BindVertexBuffer3InfoKHR {} {} {} {} {} {} {}", size_of::<BindVertexBuffer3InfoKHR>(), align_of::<BindVertexBuffer3InfoKHR>(), offset_of!(BindVertexBuffer3InfoKHR, s_type), offset_of!(BindVertexBuffer3InfoKHR, p_next), offset_of!(BindVertexBuffer3InfoKHR, set_stride), offset_of!(BindVertexBuffer3InfoKHR, address_range), offset_of!(BindVertexBuffer3InfoKHR, address_flags));
    println!("DrawIndirect2InfoKHR {} {} {} {} {} {} {}", size_of::<DrawIndirect2InfoKHR>(), align_of::<DrawIndirect2InfoKHR>(), offset_of!(DrawIndirect2InfoKHR, s_type), offset_of!(DrawIndirect2InfoKHR, p_next), offset_of!(DrawIndirect2InfoKHR, address_range), offset_of!(DrawIndirect2InfoKHR, address_flags), offset_of!(DrawIndirect2InfoKHR, draw_count));
    println!("DrawIndirectCount2InfoKHR {} {} {} {} {} {} {} {} {}", size_of::<DrawIndirectCount2InfoKHR>(), align_of::<DrawIndirectCount2InfoKHR>(), offset_of!(DrawIndirectCount2InfoKHR, s_type), offset_of!(DrawIndirectCount2InfoKHR, p_next), offset_of!(DrawIndirectCount2InfoKHR, address_range), offset_of!(DrawIndirectCount2InfoKHR, address_flags), offset_of!(DrawIndirectCount2InfoKHR, count_address_range), offset_of!(DrawIndirectCount2InfoKHR, count_address_flags), offset_of!(DrawIndirectCount2InfoKHR, max_draw_count));
    println!("DispatchIndirect2InfoKHR {} {} {} {} {} {}", size_of::<DispatchIndirect2InfoKHR>(), align_of::<DispatchIndirect2InfoKHR>(), offset_of!(DispatchIndirect2InfoKHR, s_type), offset_of!(DispatchIndirect2InfoKHR, p_next), offset_of!(DispatchIndirect2InfoKHR, address_range), offset_of!(DispatchIndirect2InfoKHR, address_flags));
    println!("BindTransformFeedbackBuffer2InfoEXT {} {} {} {} {} {}", size_of::<BindTransformFeedbackBuffer2InfoEXT>(), align_of::<BindTransformFeedbackBuffer2InfoEXT>(), offset_of!(BindTransformFeedbackBuffer2InfoEXT, s_type), offset_of!(BindTransformFeedbackBuffer2InfoEXT, p_next), offset_of!(BindTransformFeedbackBuffer2InfoEXT, address_range), offset_of!(BindTransformFeedbackBuffer2InfoEXT, address_flags));
    println!("MemoryMarkerInfoAMD {} {} {} {} {} {} {} {}", size_of::<MemoryMarkerInfoAMD>(), align_of::<MemoryMarkerInfoAMD>(), offset_of!(MemoryMarkerInfoAMD, s_type), offset_of!(MemoryMarkerInfoAMD, p_next), offset_of!(MemoryMarkerInfoAMD, stage), offset_of!(MemoryMarkerInfoAMD, dst_range), offset_of!(MemoryMarkerInfoAMD, dst_flags), offset_of!(MemoryMarkerInfoAMD, marker));
    println!("PhysicalDeviceShaderConstantDataFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderConstantDataFeaturesKHR>(), align_of::<PhysicalDeviceShaderConstantDataFeaturesKHR>(), offset_of!(PhysicalDeviceShaderConstantDataFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderConstantDataFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderConstantDataFeaturesKHR, shader_constant_data));
    println!("PhysicalDeviceShaderAbortFeaturesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderAbortFeaturesKHR>(), align_of::<PhysicalDeviceShaderAbortFeaturesKHR>(), offset_of!(PhysicalDeviceShaderAbortFeaturesKHR, s_type), offset_of!(PhysicalDeviceShaderAbortFeaturesKHR, p_next), offset_of!(PhysicalDeviceShaderAbortFeaturesKHR, shader_abort));
    println!("PhysicalDeviceShaderAbortPropertiesKHR {} {} {} {} {}", size_of::<PhysicalDeviceShaderAbortPropertiesKHR>(), align_of::<PhysicalDeviceShaderAbortPropertiesKHR>(), offset_of!(PhysicalDeviceShaderAbortPropertiesKHR, s_type), offset_of!(PhysicalDeviceShaderAbortPropertiesKHR, p_next), offset_of!(PhysicalDeviceShaderAbortPropertiesKHR, max_shader_abort_message_size));
    println!("DeviceFaultShaderAbortMessageInfoKHR {} {} {} {} {} {}", size_of::<DeviceFaultShaderAbortMessageInfoKHR>(), align_of::<DeviceFaultShaderAbortMessageInfoKHR>(), offset_of!(DeviceFaultShaderAbortMessageInfoKHR, s_type), offset_of!(DeviceFaultShaderAbortMessageInfoKHR, p_next), offset_of!(DeviceFaultShaderAbortMessageInfoKHR, message_data_size), offset_of!(DeviceFaultShaderAbortMessageInfoKHR, p_message_data));
}